Mercurial > vec
changeset 41:c6e0df09b86f
*: performance improvements with old GCC, reimplement altivec
| author | Paper <paper@tflc.us> |
|---|---|
| date | Mon, 28 Apr 2025 16:31:59 -0400 |
| parents | 55cadb1fac4b |
| children | ca0f0223a62d |
| files | include/vec/impl/altivec.h include/vec/impl/double.h include/vec/impl/gcc.h include/vec/impl/generic.h include/vec/impl/ppc/altivec.h include/vec/vec.h test/Makefile.ppc test/Makefile.template test/test.c test/test_arith.h test/test_benchmark.h test/test_benchmark_vec.c utils/genaltivec.c utils/gendouble.c utils/gengcc.c utils/gengeneric.c |
| diffstat | 16 files changed, 7478 insertions(+), 4044 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/include/vec/impl/altivec.h Mon Apr 28 16:31:59 2025 -0400 @@ -0,0 +1,1137 @@ +/** + * vec - a tiny SIMD vector library in C99 + * + * Copyright (c) 2024-2025 Paper + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. +**/ + +/* This file is automatically generated! Do not edit it directly! + * Edit the code that generates it in utils/gengcc.c --paper */ + +#ifndef VEC_IMPL_PPC_ALTIVEC_H_ +#define VEC_IMPL_PPC_ALTIVEC_H_ + + + + +/* vuint8x16 */ + +#ifdef vec_splats +#ifndef VINT8x16_SPLAT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_splat(vec_int8 x) +{ + vint8x16 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT8x16_SPLAT_DEFINED +#endif +#endif +#ifndef VINT8x16_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_load_aligned(const vec_int8 x[16]) +{ + vint8x16 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT8x16_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT8x16_LOAD_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_load(const vec_int8 x[16]) +{ + vint8x16 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT8x16_LOAD_DEFINED +#endif +#ifndef VINT8x16_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint8x16_store_aligned(vint8x16 vec, vec_int8 arr[16]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT8x16_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT8x16_STORE_DEFINED +VEC_FUNC_IMPL void vint8x16_store(vint8x16 vec, vec_int8 arr[16]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT8x16_STORE_DEFINED +#endif +#ifndef VINT8x16_ADD_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_add(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_ADD_DEFINED +#endif +#ifndef VINT8x16_SUB_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_sub(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VINT8x16_MUL_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_mul(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MUL_DEFINED +#endif +#endif +#ifndef VINT8x16_AND_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_and(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_AND_DEFINED +#endif +#ifndef VINT8x16_OR_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_or(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_OR_DEFINED +#endif +#ifndef VINT8x16_XOR_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_xor(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_XOR_DEFINED +#endif +#ifndef VINT8x16_CMPLT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPLT_DEFINED +#endif +#ifndef VINT8x16_CMPEQ_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPEQ_DEFINED +#endif +#ifndef VINT8x16_CMPGT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPGT_DEFINED +#endif +#ifndef VINT8x16_MIN_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MIN_DEFINED +#endif +#ifndef VINT8x16_MAX_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MAX_DEFINED +#endif +#ifndef VINT8x16_AVG_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_AVG_DEFINED +#endif +#ifndef VINT8x16_LSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_LSHIFT_DEFINED +#endif +#ifndef VINT8x16_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_LRSHIFT_DEFINED +#endif +#ifndef VINT8x16_RSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_RSHIFT_DEFINED +#endif + + +/* vint8x16 */ + +#ifdef vec_splats +#ifndef VUINT8x16_SPLAT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_splat(vec_uint8 x) +{ + vuint8x16 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT8x16_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_load_aligned(const vec_uint8 x[16]) +{ + vuint8x16 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT8x16_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT8x16_LOAD_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_load(const vec_uint8 x[16]) +{ + vuint8x16 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT8x16_LOAD_DEFINED +#endif +#ifndef VUINT8x16_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint8x16_store_aligned(vuint8x16 vec, vec_uint8 arr[16]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT8x16_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT8x16_STORE_DEFINED +VEC_FUNC_IMPL void vuint8x16_store(vuint8x16 vec, vec_uint8 arr[16]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT8x16_STORE_DEFINED +#endif +#ifndef VUINT8x16_ADD_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_add(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_ADD_DEFINED +#endif +#ifndef VUINT8x16_SUB_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_sub(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT8x16_MUL_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_mul(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MUL_DEFINED +#endif +#endif +#ifndef VUINT8x16_AND_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_and(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_AND_DEFINED +#endif +#ifndef VUINT8x16_OR_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_or(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_OR_DEFINED +#endif +#ifndef VUINT8x16_XOR_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_xor(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_XOR_DEFINED +#endif +#ifndef VUINT8x16_CMPLT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPLT_DEFINED +#endif +#ifndef VUINT8x16_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPEQ_DEFINED +#endif +#ifndef VUINT8x16_CMPGT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPGT_DEFINED +#endif +#ifndef VUINT8x16_MIN_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MIN_DEFINED +#endif +#ifndef VUINT8x16_MAX_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MAX_DEFINED +#endif +#ifndef VUINT8x16_AVG_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_AVG_DEFINED +#endif +#ifndef VUINT8x16_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_LSHIFT_DEFINED +#endif +#ifndef VUINT8x16_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_LRSHIFT_DEFINED +#endif +#ifndef VUINT8x16_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_RSHIFT_DEFINED +#endif + + +/* vuint16x8 */ + +#ifdef vec_splats +#ifndef VINT16x8_SPLAT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_splat(vec_int16 x) +{ + vint16x8 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT16x8_SPLAT_DEFINED +#endif +#endif +#ifndef VINT16x8_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_load_aligned(const vec_int16 x[8]) +{ + vint16x8 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT16x8_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT16x8_LOAD_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_load(const vec_int16 x[8]) +{ + vint16x8 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT16x8_LOAD_DEFINED +#endif +#ifndef VINT16x8_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint16x8_store_aligned(vint16x8 vec, vec_int16 arr[8]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT16x8_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT16x8_STORE_DEFINED +VEC_FUNC_IMPL void vint16x8_store(vint16x8 vec, vec_int16 arr[8]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT16x8_STORE_DEFINED +#endif +#ifndef VINT16x8_ADD_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_add(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_ADD_DEFINED +#endif +#ifndef VINT16x8_SUB_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_sub(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VINT16x8_MUL_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_mul(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MUL_DEFINED +#endif +#endif +#ifndef VINT16x8_AND_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_and(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_AND_DEFINED +#endif +#ifndef VINT16x8_OR_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_or(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_OR_DEFINED +#endif +#ifndef VINT16x8_XOR_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_xor(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_XOR_DEFINED +#endif +#ifndef VINT16x8_CMPLT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPLT_DEFINED +#endif +#ifndef VINT16x8_CMPEQ_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPEQ_DEFINED +#endif +#ifndef VINT16x8_CMPGT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPGT_DEFINED +#endif +#ifndef VINT16x8_MIN_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MIN_DEFINED +#endif +#ifndef VINT16x8_MAX_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MAX_DEFINED +#endif +#ifndef VINT16x8_AVG_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_AVG_DEFINED +#endif +#ifndef VINT16x8_LSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_LSHIFT_DEFINED +#endif +#ifndef VINT16x8_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_LRSHIFT_DEFINED +#endif +#ifndef VINT16x8_RSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_RSHIFT_DEFINED +#endif + + +/* vint16x8 */ + +#ifdef vec_splats +#ifndef VUINT16x8_SPLAT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_splat(vec_uint16 x) +{ + vuint16x8 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT16x8_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_load_aligned(const vec_uint16 x[8]) +{ + vuint16x8 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT16x8_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT16x8_LOAD_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_load(const vec_uint16 x[8]) +{ + vuint16x8 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT16x8_LOAD_DEFINED +#endif +#ifndef VUINT16x8_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint16x8_store_aligned(vuint16x8 vec, vec_uint16 arr[8]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT16x8_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT16x8_STORE_DEFINED +VEC_FUNC_IMPL void vuint16x8_store(vuint16x8 vec, vec_uint16 arr[8]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT16x8_STORE_DEFINED +#endif +#ifndef VUINT16x8_ADD_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_add(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_ADD_DEFINED +#endif +#ifndef VUINT16x8_SUB_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_sub(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT16x8_MUL_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_mul(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MUL_DEFINED +#endif +#endif +#ifndef VUINT16x8_AND_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_and(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_AND_DEFINED +#endif +#ifndef VUINT16x8_OR_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_or(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_OR_DEFINED +#endif +#ifndef VUINT16x8_XOR_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_xor(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_XOR_DEFINED +#endif +#ifndef VUINT16x8_CMPLT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPLT_DEFINED +#endif +#ifndef VUINT16x8_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPEQ_DEFINED +#endif +#ifndef VUINT16x8_CMPGT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPGT_DEFINED +#endif +#ifndef VUINT16x8_MIN_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MIN_DEFINED +#endif +#ifndef VUINT16x8_MAX_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MAX_DEFINED +#endif +#ifndef VUINT16x8_AVG_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_AVG_DEFINED +#endif +#ifndef VUINT16x8_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_LSHIFT_DEFINED +#endif +#ifndef VUINT16x8_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_LRSHIFT_DEFINED +#endif +#ifndef VUINT16x8_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_RSHIFT_DEFINED +#endif + + +/* vuint32x4 */ + +#ifdef vec_splats +#ifndef VINT32x4_SPLAT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_splat(vec_int32 x) +{ + vint32x4 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT32x4_SPLAT_DEFINED +#endif +#endif +#ifndef VINT32x4_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_load_aligned(const vec_int32 x[4]) +{ + vint32x4 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT32x4_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT32x4_LOAD_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_load(const vec_int32 x[4]) +{ + vint32x4 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT32x4_LOAD_DEFINED +#endif +#ifndef VINT32x4_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint32x4_store_aligned(vint32x4 vec, vec_int32 arr[4]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT32x4_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT32x4_STORE_DEFINED +VEC_FUNC_IMPL void vint32x4_store(vint32x4 vec, vec_int32 arr[4]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT32x4_STORE_DEFINED +#endif +#ifndef VINT32x4_ADD_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_add(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_ADD_DEFINED +#endif +#ifndef VINT32x4_SUB_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_sub(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VINT32x4_MUL_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_mul(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MUL_DEFINED +#endif +#endif +#ifndef VINT32x4_AND_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_and(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_AND_DEFINED +#endif +#ifndef VINT32x4_OR_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_or(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_OR_DEFINED +#endif +#ifndef VINT32x4_XOR_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_xor(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_XOR_DEFINED +#endif +#ifndef VINT32x4_CMPLT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPLT_DEFINED +#endif +#ifndef VINT32x4_CMPEQ_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPEQ_DEFINED +#endif +#ifndef VINT32x4_CMPGT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPGT_DEFINED +#endif +#ifndef VINT32x4_MIN_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MIN_DEFINED +#endif +#ifndef VINT32x4_MAX_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MAX_DEFINED +#endif +#ifndef VINT32x4_AVG_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_AVG_DEFINED +#endif +#ifndef VINT32x4_LSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_LSHIFT_DEFINED +#endif +#ifndef VINT32x4_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_LRSHIFT_DEFINED +#endif +#ifndef VINT32x4_RSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_RSHIFT_DEFINED +#endif + + +/* vint32x4 */ + +#ifdef vec_splats +#ifndef VUINT32x4_SPLAT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_splat(vec_uint32 x) +{ + vuint32x4 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT32x4_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_load_aligned(const vec_uint32 x[4]) +{ + vuint32x4 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT32x4_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT32x4_LOAD_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_load(const vec_uint32 x[4]) +{ + vuint32x4 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT32x4_LOAD_DEFINED +#endif +#ifndef VUINT32x4_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint32x4_store_aligned(vuint32x4 vec, vec_uint32 arr[4]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT32x4_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT32x4_STORE_DEFINED +VEC_FUNC_IMPL void vuint32x4_store(vuint32x4 vec, vec_uint32 arr[4]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT32x4_STORE_DEFINED +#endif +#ifndef VUINT32x4_ADD_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_add(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_ADD_DEFINED +#endif +#ifndef VUINT32x4_SUB_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_sub(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT32x4_MUL_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_mul(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MUL_DEFINED +#endif +#endif +#ifndef VUINT32x4_AND_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_and(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_AND_DEFINED +#endif +#ifndef VUINT32x4_OR_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_or(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_OR_DEFINED +#endif +#ifndef VUINT32x4_XOR_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_xor(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_XOR_DEFINED +#endif +#ifndef VUINT32x4_CMPLT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPLT_DEFINED +#endif +#ifndef VUINT32x4_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPEQ_DEFINED +#endif +#ifndef VUINT32x4_CMPGT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPGT_DEFINED +#endif +#ifndef VUINT32x4_MIN_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MIN_DEFINED +#endif +#ifndef VUINT32x4_MAX_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MAX_DEFINED +#endif +#ifndef VUINT32x4_AVG_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_AVG_DEFINED +#endif +#ifndef VUINT32x4_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_LSHIFT_DEFINED +#endif +#ifndef VUINT32x4_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_LRSHIFT_DEFINED +#endif +#ifndef VUINT32x4_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_RSHIFT_DEFINED +#endif +#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/include/vec/impl/double.h Mon Apr 28 16:31:59 2025 -0400 @@ -0,0 +1,3721 @@ +/** + * vec - a tiny SIMD vector library in C99 + * + * Copyright (c) 2024-2025 Paper + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. +**/ + +/* This file is automatically generated! Do not edit it directly! + * Edit the code that generates it in utils/gengeneric.c --paper */ + +#ifndef VEC_IMPL_DOUBLE_H_ +#define VEC_IMPL_DOUBLE_H_ + +#define VEC_DOUBLE_SPLAT(sign, bits, size, halfsize) \ + VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \ + { \ + v##sign##int##bits##x##size vec; \ + \ + vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \ + vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \ + \ + return vec; \ + } + +#define VEC_DOUBLE_LOAD_EX(name, sign, bits, size, halfsize) \ + VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \ + { \ + v##sign##int##bits##x##size vec; \ + \ + vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \ + vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \ + \ + return vec; \ + } + +#define VEC_DOUBLE_LOAD(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load, sign, bits, size, halfsize) +#define VEC_DOUBLE_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load_aligned, sign, bits, size, halfsize) + +#define VEC_DOUBLE_STORE_EX(name, sign, bits, size, halfsize) \ + VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \ + { \ + v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \ + v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \ + } + +#define VEC_DOUBLE_STORE(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store, sign, bits, size, halfsize) +#define VEC_DOUBLE_STORE_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store_aligned, sign, bits, size, halfsize) + +#define VEC_DOUBLE_OP(name, sign, bits, size, halfsize, secondsign) \ + VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \ + { \ + vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \ + vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \ + \ + return vec1; \ + } + +#define VEC_DOUBLE_ADD(sign, bits, size, halfsize) VEC_DOUBLE_OP(add, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_SUB(sign, bits, size, halfsize) VEC_DOUBLE_OP(sub, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_MUL(sign, bits, size, halfsize) VEC_DOUBLE_OP(mul, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_DIV(sign, bits, size, halfsize) VEC_DOUBLE_OP(div, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_MOD(sign, bits, size, halfsize) VEC_DOUBLE_OP(mod, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_AVG(sign, bits, size, halfsize) VEC_DOUBLE_OP(avg, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_LSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lshift, sign, bits, size, halfsize, u) +#define VEC_DOUBLE_RSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(rshift, sign, bits, size, halfsize, u) +#define VEC_DOUBLE_LRSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lrshift, sign, bits, size, halfsize, u) +#define VEC_DOUBLE_AND(sign, bits, size, halfsize) VEC_DOUBLE_OP(and, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_OR(sign, bits, size, halfsize) VEC_DOUBLE_OP(or, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_XOR(sign, bits, size, halfsize) VEC_DOUBLE_OP(xor, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_MIN(sign, bits, size, halfsize) VEC_DOUBLE_OP(min, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_MAX(sign, bits, size, halfsize) VEC_DOUBLE_OP(max, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_CMPLT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmplt, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_CMPLE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmple, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_CMPEQ(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpeq, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_CMPGE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpge, sign, bits, size, halfsize, sign) +#define VEC_DOUBLE_CMPGT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpgt, sign, bits, size, halfsize, sign) + +#define VEC_DOUBLE_NOT(sign, bits, size, halfsize) \ + VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \ + { \ + vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \ + vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \ + \ + return vec; \ + } + +#endif /* VEC_IMPL_DOUBLE_H_ */ + +/* ------------------------------------------------------------------------ */ +/* PREPROCESSOR HELL INCOMING */ + + + +/* vuint8x4 */ + +#if !defined(VINT8x4_SPLAT_DEFINED) && defined(VINT8x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 8, 4, 2) +# define VINT8x4_SPLAT_DEFINED +#endif + +#if !defined(VINT8x4_LOAD_ALIGNED_DEFINED) && defined(VINT8x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 4, 2) +# define VINT8x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x4_LOAD_DEFINED) && defined(VINT8x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 8, 4, 2) +# define VINT8x4_LOAD_DEFINED +#endif + +#if !defined(VINT8x4_STORE_ALIGNED_DEFINED) && defined(VINT8x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 4, 2) +# define VINT8x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x4_STORE_DEFINED) && defined(VINT8x2_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 8, 4, 2) +# define VINT8x4_STORE_DEFINED +#endif + +#if !defined(VINT8x4_ADD_DEFINED) && defined(VINT8x2_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 8, 4, 2) +# define VINT8x4_ADD_DEFINED +#endif + +#if !defined(VINT8x4_SUB_DEFINED) && defined(VINT8x2_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 8, 4, 2) +# define VINT8x4_SUB_DEFINED +#endif + +#if !defined(VINT8x4_MUL_DEFINED) && defined(VINT8x2_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 8, 4, 2) +# define VINT8x4_MUL_DEFINED +#endif + +#if !defined(VINT8x4_DIV_DEFINED) && defined(VINT8x2_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 8, 4, 2) +# define VINT8x4_DIV_DEFINED +#endif + +#if !defined(VINT8x4_MOD_DEFINED) && defined(VINT8x2_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 8, 4, 2) +# define VINT8x4_MOD_DEFINED +#endif + +#if !defined(VINT8x4_AVG_DEFINED) && defined(VINT8x2_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 8, 4, 2) +# define VINT8x4_AVG_DEFINED +#endif + +#if !defined(VINT8x4_AND_DEFINED) && defined(VINT8x2_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 8, 4, 2) +# define VINT8x4_AND_DEFINED +#endif + +#if !defined(VINT8x4_OR_DEFINED) && defined(VINT8x2_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 8, 4, 2) +# define VINT8x4_OR_DEFINED +#endif + +#if !defined(VINT8x4_XOR_DEFINED) && defined(VINT8x2_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 8, 4, 2) +# define VINT8x4_XOR_DEFINED +#endif + +#if !defined(VINT8x4_NOT_DEFINED) && defined(VINT8x2_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 8, 4, 2) +# define VINT8x4_NOT_DEFINED +#endif + +#if !defined(VINT8x4_CMPLT_DEFINED) && defined(VINT8x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 8, 4, 2) +# define VINT8x4_CMPLT_DEFINED +#endif + +#if !defined(VINT8x4_CMPEQ_DEFINED) && defined(VINT8x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 8, 4, 2) +# define VINT8x4_CMPEQ_DEFINED +#endif + +#if !defined(VINT8x4_CMPGT_DEFINED) && defined(VINT8x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 8, 4, 2) +# define VINT8x4_CMPGT_DEFINED +#endif + +#if !defined(VINT8x4_CMPLE_DEFINED) && defined(VINT8x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 8, 4, 2) +# define VINT8x4_CMPLE_DEFINED +#endif + +#if !defined(VINT8x4_CMPGE_DEFINED) && defined(VINT8x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 8, 4, 2) +# define VINT8x4_CMPGE_DEFINED +#endif + +#if !defined(VINT8x4_MIN_DEFINED) && defined(VINT8x2_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 8, 4, 2) +# define VINT8x4_MIN_DEFINED +#endif + +#if !defined(VINT8x4_MAX_DEFINED) && defined(VINT8x2_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 8, 4, 2) +# define VINT8x4_MAX_DEFINED +#endif + +#if !defined(VINT8x4_RSHIFT_DEFINED) && defined(VINT8x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 8, 4, 2) +# define VINT8x4_RSHIFT_DEFINED +#endif + +#if !defined(VINT8x4_LRSHIFT_DEFINED) && defined(VINT8x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 4, 2) +# define VINT8x4_LRSHIFT_DEFINED +#endif + +#if !defined(VINT8x4_LSHIFT_DEFINED) && defined(VINT8x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 8, 4, 2) +# define VINT8x4_LSHIFT_DEFINED +#endif + + + +/* vint8x4 */ + +#if !defined(VUINT8x4_SPLAT_DEFINED) && defined(VUINT8x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 8, 4, 2) +# define VUINT8x4_SPLAT_DEFINED +#endif + +#if !defined(VUINT8x4_LOAD_ALIGNED_DEFINED) && defined(VUINT8x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 8, 4, 2) +# define VUINT8x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x4_LOAD_DEFINED) && defined(VUINT8x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 8, 4, 2) +# define VUINT8x4_LOAD_DEFINED +#endif + +#if !defined(VUINT8x4_STORE_ALIGNED_DEFINED) && defined(VUINT8x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 8, 4, 2) +# define VUINT8x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x4_STORE_DEFINED) && defined(VUINT8x2_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 8, 4, 2) +# define VUINT8x4_STORE_DEFINED +#endif + +#if !defined(VUINT8x4_ADD_DEFINED) && defined(VUINT8x2_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 8, 4, 2) +# define VUINT8x4_ADD_DEFINED +#endif + +#if !defined(VUINT8x4_SUB_DEFINED) && defined(VUINT8x2_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 8, 4, 2) +# define VUINT8x4_SUB_DEFINED +#endif + +#if !defined(VUINT8x4_MUL_DEFINED) && defined(VUINT8x2_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 8, 4, 2) +# define VUINT8x4_MUL_DEFINED +#endif + +#if !defined(VUINT8x4_DIV_DEFINED) && defined(VUINT8x2_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 8, 4, 2) +# define VUINT8x4_DIV_DEFINED +#endif + +#if !defined(VUINT8x4_MOD_DEFINED) && defined(VUINT8x2_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 8, 4, 2) +# define VUINT8x4_MOD_DEFINED +#endif + +#if !defined(VUINT8x4_AVG_DEFINED) && defined(VUINT8x2_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 8, 4, 2) +# define VUINT8x4_AVG_DEFINED +#endif + +#if !defined(VUINT8x4_AND_DEFINED) && defined(VUINT8x2_AND_DEFINED) +VEC_DOUBLE_AND(u, 8, 4, 2) +# define VUINT8x4_AND_DEFINED +#endif + +#if !defined(VUINT8x4_OR_DEFINED) && defined(VUINT8x2_OR_DEFINED) +VEC_DOUBLE_OR(u, 8, 4, 2) +# define VUINT8x4_OR_DEFINED +#endif + +#if !defined(VUINT8x4_XOR_DEFINED) && defined(VUINT8x2_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 8, 4, 2) +# define VUINT8x4_XOR_DEFINED +#endif + +#if !defined(VUINT8x4_NOT_DEFINED) && defined(VUINT8x2_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 8, 4, 2) +# define VUINT8x4_NOT_DEFINED +#endif + +#if !defined(VUINT8x4_CMPLT_DEFINED) && defined(VUINT8x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 8, 4, 2) +# define VUINT8x4_CMPLT_DEFINED +#endif + +#if !defined(VUINT8x4_CMPEQ_DEFINED) && defined(VUINT8x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 8, 4, 2) +# define VUINT8x4_CMPEQ_DEFINED +#endif + +#if !defined(VUINT8x4_CMPGT_DEFINED) && defined(VUINT8x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 8, 4, 2) +# define VUINT8x4_CMPGT_DEFINED +#endif + +#if !defined(VUINT8x4_CMPLE_DEFINED) && defined(VUINT8x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 8, 4, 2) +# define VUINT8x4_CMPLE_DEFINED +#endif + +#if !defined(VUINT8x4_CMPGE_DEFINED) && defined(VUINT8x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 8, 4, 2) +# define VUINT8x4_CMPGE_DEFINED +#endif + +#if !defined(VUINT8x4_MIN_DEFINED) && defined(VUINT8x2_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 8, 4, 2) +# define VUINT8x4_MIN_DEFINED +#endif + +#if !defined(VUINT8x4_MAX_DEFINED) && defined(VUINT8x2_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 8, 4, 2) +# define VUINT8x4_MAX_DEFINED +#endif + +#if !defined(VUINT8x4_RSHIFT_DEFINED) && defined(VUINT8x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 8, 4, 2) +# define VUINT8x4_RSHIFT_DEFINED +#endif + +#if !defined(VUINT8x4_LRSHIFT_DEFINED) && defined(VUINT8x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 8, 4, 2) +# define VUINT8x4_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT8x4_LSHIFT_DEFINED) && defined(VUINT8x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 8, 4, 2) +# define VUINT8x4_LSHIFT_DEFINED +#endif + + + +/* vuint8x8 */ + +#if !defined(VINT8x8_SPLAT_DEFINED) && defined(VINT8x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 8, 8, 4) +# define VINT8x8_SPLAT_DEFINED +#endif + +#if !defined(VINT8x8_LOAD_ALIGNED_DEFINED) && defined(VINT8x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 8, 4) +# define VINT8x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x8_LOAD_DEFINED) && defined(VINT8x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 8, 8, 4) +# define VINT8x8_LOAD_DEFINED +#endif + +#if !defined(VINT8x8_STORE_ALIGNED_DEFINED) && defined(VINT8x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 8, 4) +# define VINT8x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x8_STORE_DEFINED) && defined(VINT8x4_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 8, 8, 4) +# define VINT8x8_STORE_DEFINED +#endif + +#if !defined(VINT8x8_ADD_DEFINED) && defined(VINT8x4_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 8, 8, 4) +# define VINT8x8_ADD_DEFINED +#endif + +#if !defined(VINT8x8_SUB_DEFINED) && defined(VINT8x4_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 8, 8, 4) +# define VINT8x8_SUB_DEFINED +#endif + +#if !defined(VINT8x8_MUL_DEFINED) && defined(VINT8x4_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 8, 8, 4) +# define VINT8x8_MUL_DEFINED +#endif + +#if !defined(VINT8x8_DIV_DEFINED) && defined(VINT8x4_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 8, 8, 4) +# define VINT8x8_DIV_DEFINED +#endif + +#if !defined(VINT8x8_MOD_DEFINED) && defined(VINT8x4_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 8, 8, 4) +# define VINT8x8_MOD_DEFINED +#endif + +#if !defined(VINT8x8_AVG_DEFINED) && defined(VINT8x4_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 8, 8, 4) +# define VINT8x8_AVG_DEFINED +#endif + +#if !defined(VINT8x8_AND_DEFINED) && defined(VINT8x4_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 8, 8, 4) +# define VINT8x8_AND_DEFINED +#endif + +#if !defined(VINT8x8_OR_DEFINED) && defined(VINT8x4_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 8, 8, 4) +# define VINT8x8_OR_DEFINED +#endif + +#if !defined(VINT8x8_XOR_DEFINED) && defined(VINT8x4_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 8, 8, 4) +# define VINT8x8_XOR_DEFINED +#endif + +#if !defined(VINT8x8_NOT_DEFINED) && defined(VINT8x4_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 8, 8, 4) +# define VINT8x8_NOT_DEFINED +#endif + +#if !defined(VINT8x8_CMPLT_DEFINED) && defined(VINT8x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 8, 8, 4) +# define VINT8x8_CMPLT_DEFINED +#endif + +#if !defined(VINT8x8_CMPEQ_DEFINED) && defined(VINT8x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 8, 8, 4) +# define VINT8x8_CMPEQ_DEFINED +#endif + +#if !defined(VINT8x8_CMPGT_DEFINED) && defined(VINT8x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 8, 8, 4) +# define VINT8x8_CMPGT_DEFINED +#endif + +#if !defined(VINT8x8_CMPLE_DEFINED) && defined(VINT8x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 8, 8, 4) +# define VINT8x8_CMPLE_DEFINED +#endif + +#if !defined(VINT8x8_CMPGE_DEFINED) && defined(VINT8x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 8, 8, 4) +# define VINT8x8_CMPGE_DEFINED +#endif + +#if !defined(VINT8x8_MIN_DEFINED) && defined(VINT8x4_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 8, 8, 4) +# define VINT8x8_MIN_DEFINED +#endif + +#if !defined(VINT8x8_MAX_DEFINED) && defined(VINT8x4_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 8, 8, 4) +# define VINT8x8_MAX_DEFINED +#endif + +#if !defined(VINT8x8_RSHIFT_DEFINED) && defined(VINT8x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 8, 8, 4) +# define VINT8x8_RSHIFT_DEFINED +#endif + +#if !defined(VINT8x8_LRSHIFT_DEFINED) && defined(VINT8x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 8, 4) +# define VINT8x8_LRSHIFT_DEFINED +#endif + +#if !defined(VINT8x8_LSHIFT_DEFINED) && defined(VINT8x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 8, 8, 4) +# define VINT8x8_LSHIFT_DEFINED +#endif + + + +/* vint8x8 */ + +#if !defined(VUINT8x8_SPLAT_DEFINED) && defined(VUINT8x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 8, 8, 4) +# define VUINT8x8_SPLAT_DEFINED +#endif + +#if !defined(VUINT8x8_LOAD_ALIGNED_DEFINED) && defined(VUINT8x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 8, 8, 4) +# define VUINT8x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x8_LOAD_DEFINED) && defined(VUINT8x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 8, 8, 4) +# define VUINT8x8_LOAD_DEFINED +#endif + +#if !defined(VUINT8x8_STORE_ALIGNED_DEFINED) && defined(VUINT8x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 8, 8, 4) +# define VUINT8x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x8_STORE_DEFINED) && defined(VUINT8x4_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 8, 8, 4) +# define VUINT8x8_STORE_DEFINED +#endif + +#if !defined(VUINT8x8_ADD_DEFINED) && defined(VUINT8x4_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 8, 8, 4) +# define VUINT8x8_ADD_DEFINED +#endif + +#if !defined(VUINT8x8_SUB_DEFINED) && defined(VUINT8x4_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 8, 8, 4) +# define VUINT8x8_SUB_DEFINED +#endif + +#if !defined(VUINT8x8_MUL_DEFINED) && defined(VUINT8x4_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 8, 8, 4) +# define VUINT8x8_MUL_DEFINED +#endif + +#if !defined(VUINT8x8_DIV_DEFINED) && defined(VUINT8x4_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 8, 8, 4) +# define VUINT8x8_DIV_DEFINED +#endif + +#if !defined(VUINT8x8_MOD_DEFINED) && defined(VUINT8x4_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 8, 8, 4) +# define VUINT8x8_MOD_DEFINED +#endif + +#if !defined(VUINT8x8_AVG_DEFINED) && defined(VUINT8x4_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 8, 8, 4) +# define VUINT8x8_AVG_DEFINED +#endif + +#if !defined(VUINT8x8_AND_DEFINED) && defined(VUINT8x4_AND_DEFINED) +VEC_DOUBLE_AND(u, 8, 8, 4) +# define VUINT8x8_AND_DEFINED +#endif + +#if !defined(VUINT8x8_OR_DEFINED) && defined(VUINT8x4_OR_DEFINED) +VEC_DOUBLE_OR(u, 8, 8, 4) +# define VUINT8x8_OR_DEFINED +#endif + +#if !defined(VUINT8x8_XOR_DEFINED) && defined(VUINT8x4_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 8, 8, 4) +# define VUINT8x8_XOR_DEFINED +#endif + +#if !defined(VUINT8x8_NOT_DEFINED) && defined(VUINT8x4_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 8, 8, 4) +# define VUINT8x8_NOT_DEFINED +#endif + +#if !defined(VUINT8x8_CMPLT_DEFINED) && defined(VUINT8x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 8, 8, 4) +# define VUINT8x8_CMPLT_DEFINED +#endif + +#if !defined(VUINT8x8_CMPEQ_DEFINED) && defined(VUINT8x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 8, 8, 4) +# define VUINT8x8_CMPEQ_DEFINED +#endif + +#if !defined(VUINT8x8_CMPGT_DEFINED) && defined(VUINT8x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 8, 8, 4) +# define VUINT8x8_CMPGT_DEFINED +#endif + +#if !defined(VUINT8x8_CMPLE_DEFINED) && defined(VUINT8x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 8, 8, 4) +# define VUINT8x8_CMPLE_DEFINED +#endif + +#if !defined(VUINT8x8_CMPGE_DEFINED) && defined(VUINT8x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 8, 8, 4) +# define VUINT8x8_CMPGE_DEFINED +#endif + +#if !defined(VUINT8x8_MIN_DEFINED) && defined(VUINT8x4_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 8, 8, 4) +# define VUINT8x8_MIN_DEFINED +#endif + +#if !defined(VUINT8x8_MAX_DEFINED) && defined(VUINT8x4_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 8, 8, 4) +# define VUINT8x8_MAX_DEFINED +#endif + +#if !defined(VUINT8x8_RSHIFT_DEFINED) && defined(VUINT8x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 8, 8, 4) +# define VUINT8x8_RSHIFT_DEFINED +#endif + +#if !defined(VUINT8x8_LRSHIFT_DEFINED) && defined(VUINT8x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 8, 8, 4) +# define VUINT8x8_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT8x8_LSHIFT_DEFINED) && defined(VUINT8x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 8, 8, 4) +# define VUINT8x8_LSHIFT_DEFINED +#endif + + + +/* vuint8x16 */ + +#if !defined(VINT8x16_SPLAT_DEFINED) && defined(VINT8x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 8, 16, 8) +# define VINT8x16_SPLAT_DEFINED +#endif + +#if !defined(VINT8x16_LOAD_ALIGNED_DEFINED) && defined(VINT8x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 16, 8) +# define VINT8x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x16_LOAD_DEFINED) && defined(VINT8x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 8, 16, 8) +# define VINT8x16_LOAD_DEFINED +#endif + +#if !defined(VINT8x16_STORE_ALIGNED_DEFINED) && defined(VINT8x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 16, 8) +# define VINT8x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x16_STORE_DEFINED) && defined(VINT8x8_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 8, 16, 8) +# define VINT8x16_STORE_DEFINED +#endif + +#if !defined(VINT8x16_ADD_DEFINED) && defined(VINT8x8_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 8, 16, 8) +# define VINT8x16_ADD_DEFINED +#endif + +#if !defined(VINT8x16_SUB_DEFINED) && defined(VINT8x8_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 8, 16, 8) +# define VINT8x16_SUB_DEFINED +#endif + +#if !defined(VINT8x16_MUL_DEFINED) && defined(VINT8x8_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 8, 16, 8) +# define VINT8x16_MUL_DEFINED +#endif + +#if !defined(VINT8x16_DIV_DEFINED) && defined(VINT8x8_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 8, 16, 8) +# define VINT8x16_DIV_DEFINED +#endif + +#if !defined(VINT8x16_MOD_DEFINED) && defined(VINT8x8_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 8, 16, 8) +# define VINT8x16_MOD_DEFINED +#endif + +#if !defined(VINT8x16_AVG_DEFINED) && defined(VINT8x8_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 8, 16, 8) +# define VINT8x16_AVG_DEFINED +#endif + +#if !defined(VINT8x16_AND_DEFINED) && defined(VINT8x8_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 8, 16, 8) +# define VINT8x16_AND_DEFINED +#endif + +#if !defined(VINT8x16_OR_DEFINED) && defined(VINT8x8_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 8, 16, 8) +# define VINT8x16_OR_DEFINED +#endif + +#if !defined(VINT8x16_XOR_DEFINED) && defined(VINT8x8_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 8, 16, 8) +# define VINT8x16_XOR_DEFINED +#endif + +#if !defined(VINT8x16_NOT_DEFINED) && defined(VINT8x8_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 8, 16, 8) +# define VINT8x16_NOT_DEFINED +#endif + +#if !defined(VINT8x16_CMPLT_DEFINED) && defined(VINT8x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 8, 16, 8) +# define VINT8x16_CMPLT_DEFINED +#endif + +#if !defined(VINT8x16_CMPEQ_DEFINED) && defined(VINT8x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 8, 16, 8) +# define VINT8x16_CMPEQ_DEFINED +#endif + +#if !defined(VINT8x16_CMPGT_DEFINED) && defined(VINT8x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 8, 16, 8) +# define VINT8x16_CMPGT_DEFINED +#endif + +#if !defined(VINT8x16_CMPLE_DEFINED) && defined(VINT8x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 8, 16, 8) +# define VINT8x16_CMPLE_DEFINED +#endif + +#if !defined(VINT8x16_CMPGE_DEFINED) && defined(VINT8x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 8, 16, 8) +# define VINT8x16_CMPGE_DEFINED +#endif + +#if !defined(VINT8x16_MIN_DEFINED) && defined(VINT8x8_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 8, 16, 8) +# define VINT8x16_MIN_DEFINED +#endif + +#if !defined(VINT8x16_MAX_DEFINED) && defined(VINT8x8_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 8, 16, 8) +# define VINT8x16_MAX_DEFINED +#endif + +#if !defined(VINT8x16_RSHIFT_DEFINED) && defined(VINT8x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 8, 16, 8) +# define VINT8x16_RSHIFT_DEFINED +#endif + +#if !defined(VINT8x16_LRSHIFT_DEFINED) && defined(VINT8x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 16, 8) +# define VINT8x16_LRSHIFT_DEFINED +#endif + +#if !defined(VINT8x16_LSHIFT_DEFINED) && defined(VINT8x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 8, 16, 8) +# define VINT8x16_LSHIFT_DEFINED +#endif + + + +/* vint8x16 */ + +#if !defined(VUINT8x16_SPLAT_DEFINED) && defined(VUINT8x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 8, 16, 8) +# define VUINT8x16_SPLAT_DEFINED +#endif + +#if !defined(VUINT8x16_LOAD_ALIGNED_DEFINED) && defined(VUINT8x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 8, 16, 8) +# define VUINT8x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x16_LOAD_DEFINED) && defined(VUINT8x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 8, 16, 8) +# define VUINT8x16_LOAD_DEFINED +#endif + +#if !defined(VUINT8x16_STORE_ALIGNED_DEFINED) && defined(VUINT8x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 8, 16, 8) +# define VUINT8x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x16_STORE_DEFINED) && defined(VUINT8x8_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 8, 16, 8) +# define VUINT8x16_STORE_DEFINED +#endif + +#if !defined(VUINT8x16_ADD_DEFINED) && defined(VUINT8x8_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 8, 16, 8) +# define VUINT8x16_ADD_DEFINED +#endif + +#if !defined(VUINT8x16_SUB_DEFINED) && defined(VUINT8x8_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 8, 16, 8) +# define VUINT8x16_SUB_DEFINED +#endif + +#if !defined(VUINT8x16_MUL_DEFINED) && defined(VUINT8x8_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 8, 16, 8) +# define VUINT8x16_MUL_DEFINED +#endif + +#if !defined(VUINT8x16_DIV_DEFINED) && defined(VUINT8x8_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 8, 16, 8) +# define VUINT8x16_DIV_DEFINED +#endif + +#if !defined(VUINT8x16_MOD_DEFINED) && defined(VUINT8x8_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 8, 16, 8) +# define VUINT8x16_MOD_DEFINED +#endif + +#if !defined(VUINT8x16_AVG_DEFINED) && defined(VUINT8x8_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 8, 16, 8) +# define VUINT8x16_AVG_DEFINED +#endif + +#if !defined(VUINT8x16_AND_DEFINED) && defined(VUINT8x8_AND_DEFINED) +VEC_DOUBLE_AND(u, 8, 16, 8) +# define VUINT8x16_AND_DEFINED +#endif + +#if !defined(VUINT8x16_OR_DEFINED) && defined(VUINT8x8_OR_DEFINED) +VEC_DOUBLE_OR(u, 8, 16, 8) +# define VUINT8x16_OR_DEFINED +#endif + +#if !defined(VUINT8x16_XOR_DEFINED) && defined(VUINT8x8_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 8, 16, 8) +# define VUINT8x16_XOR_DEFINED +#endif + +#if !defined(VUINT8x16_NOT_DEFINED) && defined(VUINT8x8_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 8, 16, 8) +# define VUINT8x16_NOT_DEFINED +#endif + +#if !defined(VUINT8x16_CMPLT_DEFINED) && defined(VUINT8x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 8, 16, 8) +# define VUINT8x16_CMPLT_DEFINED +#endif + +#if !defined(VUINT8x16_CMPEQ_DEFINED) && defined(VUINT8x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 8, 16, 8) +# define VUINT8x16_CMPEQ_DEFINED +#endif + +#if !defined(VUINT8x16_CMPGT_DEFINED) && defined(VUINT8x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 8, 16, 8) +# define VUINT8x16_CMPGT_DEFINED +#endif + +#if !defined(VUINT8x16_CMPLE_DEFINED) && defined(VUINT8x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 8, 16, 8) +# define VUINT8x16_CMPLE_DEFINED +#endif + +#if !defined(VUINT8x16_CMPGE_DEFINED) && defined(VUINT8x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 8, 16, 8) +# define VUINT8x16_CMPGE_DEFINED +#endif + +#if !defined(VUINT8x16_MIN_DEFINED) && defined(VUINT8x8_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 8, 16, 8) +# define VUINT8x16_MIN_DEFINED +#endif + +#if !defined(VUINT8x16_MAX_DEFINED) && defined(VUINT8x8_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 8, 16, 8) +# define VUINT8x16_MAX_DEFINED +#endif + +#if !defined(VUINT8x16_RSHIFT_DEFINED) && defined(VUINT8x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 8, 16, 8) +# define VUINT8x16_RSHIFT_DEFINED +#endif + +#if !defined(VUINT8x16_LRSHIFT_DEFINED) && defined(VUINT8x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 8, 16, 8) +# define VUINT8x16_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT8x16_LSHIFT_DEFINED) && defined(VUINT8x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 8, 16, 8) +# define VUINT8x16_LSHIFT_DEFINED +#endif + + + +/* vuint8x32 */ + +#if !defined(VINT8x32_SPLAT_DEFINED) && defined(VINT8x16_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 8, 32, 16) +# define VINT8x32_SPLAT_DEFINED +#endif + +#if !defined(VINT8x32_LOAD_ALIGNED_DEFINED) && defined(VINT8x16_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 32, 16) +# define VINT8x32_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x32_LOAD_DEFINED) && defined(VINT8x16_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 8, 32, 16) +# define VINT8x32_LOAD_DEFINED +#endif + +#if !defined(VINT8x32_STORE_ALIGNED_DEFINED) && defined(VINT8x16_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 32, 16) +# define VINT8x32_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x32_STORE_DEFINED) && defined(VINT8x16_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 8, 32, 16) +# define VINT8x32_STORE_DEFINED +#endif + +#if !defined(VINT8x32_ADD_DEFINED) && defined(VINT8x16_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 8, 32, 16) +# define VINT8x32_ADD_DEFINED +#endif + +#if !defined(VINT8x32_SUB_DEFINED) && defined(VINT8x16_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 8, 32, 16) +# define VINT8x32_SUB_DEFINED +#endif + +#if !defined(VINT8x32_MUL_DEFINED) && defined(VINT8x16_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 8, 32, 16) +# define VINT8x32_MUL_DEFINED +#endif + +#if !defined(VINT8x32_DIV_DEFINED) && defined(VINT8x16_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 8, 32, 16) +# define VINT8x32_DIV_DEFINED +#endif + +#if !defined(VINT8x32_MOD_DEFINED) && defined(VINT8x16_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 8, 32, 16) +# define VINT8x32_MOD_DEFINED +#endif + +#if !defined(VINT8x32_AVG_DEFINED) && defined(VINT8x16_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 8, 32, 16) +# define VINT8x32_AVG_DEFINED +#endif + +#if !defined(VINT8x32_AND_DEFINED) && defined(VINT8x16_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 8, 32, 16) +# define VINT8x32_AND_DEFINED +#endif + +#if !defined(VINT8x32_OR_DEFINED) && defined(VINT8x16_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 8, 32, 16) +# define VINT8x32_OR_DEFINED +#endif + +#if !defined(VINT8x32_XOR_DEFINED) && defined(VINT8x16_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 8, 32, 16) +# define VINT8x32_XOR_DEFINED +#endif + +#if !defined(VINT8x32_NOT_DEFINED) && defined(VINT8x16_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 8, 32, 16) +# define VINT8x32_NOT_DEFINED +#endif + +#if !defined(VINT8x32_CMPLT_DEFINED) && defined(VINT8x16_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 8, 32, 16) +# define VINT8x32_CMPLT_DEFINED +#endif + +#if !defined(VINT8x32_CMPEQ_DEFINED) && defined(VINT8x16_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 8, 32, 16) +# define VINT8x32_CMPEQ_DEFINED +#endif + +#if !defined(VINT8x32_CMPGT_DEFINED) && defined(VINT8x16_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 8, 32, 16) +# define VINT8x32_CMPGT_DEFINED +#endif + +#if !defined(VINT8x32_CMPLE_DEFINED) && defined(VINT8x16_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 8, 32, 16) +# define VINT8x32_CMPLE_DEFINED +#endif + +#if !defined(VINT8x32_CMPGE_DEFINED) && defined(VINT8x16_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 8, 32, 16) +# define VINT8x32_CMPGE_DEFINED +#endif + +#if !defined(VINT8x32_MIN_DEFINED) && defined(VINT8x16_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 8, 32, 16) +# define VINT8x32_MIN_DEFINED +#endif + +#if !defined(VINT8x32_MAX_DEFINED) && defined(VINT8x16_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 8, 32, 16) +# define VINT8x32_MAX_DEFINED +#endif + +#if !defined(VINT8x32_RSHIFT_DEFINED) && defined(VINT8x16_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 8, 32, 16) +# define VINT8x32_RSHIFT_DEFINED +#endif + +#if !defined(VINT8x32_LRSHIFT_DEFINED) && defined(VINT8x16_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 32, 16) +# define VINT8x32_LRSHIFT_DEFINED +#endif + +#if !defined(VINT8x32_LSHIFT_DEFINED) && defined(VINT8x16_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 8, 32, 16) +# define VINT8x32_LSHIFT_DEFINED +#endif + + + +/* vint8x32 */ + +#if !defined(VUINT8x32_SPLAT_DEFINED) && defined(VUINT8x16_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 8, 32, 16) +# define VUINT8x32_SPLAT_DEFINED +#endif + +#if !defined(VUINT8x32_LOAD_ALIGNED_DEFINED) && defined(VUINT8x16_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 8, 32, 16) +# define VUINT8x32_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x32_LOAD_DEFINED) && defined(VUINT8x16_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 8, 32, 16) +# define VUINT8x32_LOAD_DEFINED +#endif + +#if !defined(VUINT8x32_STORE_ALIGNED_DEFINED) && defined(VUINT8x16_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 8, 32, 16) +# define VUINT8x32_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x32_STORE_DEFINED) && defined(VUINT8x16_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 8, 32, 16) +# define VUINT8x32_STORE_DEFINED +#endif + +#if !defined(VUINT8x32_ADD_DEFINED) && defined(VUINT8x16_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 8, 32, 16) +# define VUINT8x32_ADD_DEFINED +#endif + +#if !defined(VUINT8x32_SUB_DEFINED) && defined(VUINT8x16_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 8, 32, 16) +# define VUINT8x32_SUB_DEFINED +#endif + +#if !defined(VUINT8x32_MUL_DEFINED) && defined(VUINT8x16_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 8, 32, 16) +# define VUINT8x32_MUL_DEFINED +#endif + +#if !defined(VUINT8x32_DIV_DEFINED) && defined(VUINT8x16_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 8, 32, 16) +# define VUINT8x32_DIV_DEFINED +#endif + +#if !defined(VUINT8x32_MOD_DEFINED) && defined(VUINT8x16_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 8, 32, 16) +# define VUINT8x32_MOD_DEFINED +#endif + +#if !defined(VUINT8x32_AVG_DEFINED) && defined(VUINT8x16_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 8, 32, 16) +# define VUINT8x32_AVG_DEFINED +#endif + +#if !defined(VUINT8x32_AND_DEFINED) && defined(VUINT8x16_AND_DEFINED) +VEC_DOUBLE_AND(u, 8, 32, 16) +# define VUINT8x32_AND_DEFINED +#endif + +#if !defined(VUINT8x32_OR_DEFINED) && defined(VUINT8x16_OR_DEFINED) +VEC_DOUBLE_OR(u, 8, 32, 16) +# define VUINT8x32_OR_DEFINED +#endif + +#if !defined(VUINT8x32_XOR_DEFINED) && defined(VUINT8x16_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 8, 32, 16) +# define VUINT8x32_XOR_DEFINED +#endif + +#if !defined(VUINT8x32_NOT_DEFINED) && defined(VUINT8x16_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 8, 32, 16) +# define VUINT8x32_NOT_DEFINED +#endif + +#if !defined(VUINT8x32_CMPLT_DEFINED) && defined(VUINT8x16_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 8, 32, 16) +# define VUINT8x32_CMPLT_DEFINED +#endif + +#if !defined(VUINT8x32_CMPEQ_DEFINED) && defined(VUINT8x16_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 8, 32, 16) +# define VUINT8x32_CMPEQ_DEFINED +#endif + +#if !defined(VUINT8x32_CMPGT_DEFINED) && defined(VUINT8x16_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 8, 32, 16) +# define VUINT8x32_CMPGT_DEFINED +#endif + +#if !defined(VUINT8x32_CMPLE_DEFINED) && defined(VUINT8x16_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 8, 32, 16) +# define VUINT8x32_CMPLE_DEFINED +#endif + +#if !defined(VUINT8x32_CMPGE_DEFINED) && defined(VUINT8x16_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 8, 32, 16) +# define VUINT8x32_CMPGE_DEFINED +#endif + +#if !defined(VUINT8x32_MIN_DEFINED) && defined(VUINT8x16_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 8, 32, 16) +# define VUINT8x32_MIN_DEFINED +#endif + +#if !defined(VUINT8x32_MAX_DEFINED) && defined(VUINT8x16_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 8, 32, 16) +# define VUINT8x32_MAX_DEFINED +#endif + +#if !defined(VUINT8x32_RSHIFT_DEFINED) && defined(VUINT8x16_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 8, 32, 16) +# define VUINT8x32_RSHIFT_DEFINED +#endif + +#if !defined(VUINT8x32_LRSHIFT_DEFINED) && defined(VUINT8x16_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 8, 32, 16) +# define VUINT8x32_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT8x32_LSHIFT_DEFINED) && defined(VUINT8x16_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 8, 32, 16) +# define VUINT8x32_LSHIFT_DEFINED +#endif + + + +/* vuint8x64 */ + +#if !defined(VINT8x64_SPLAT_DEFINED) && defined(VINT8x32_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 8, 64, 32) +# define VINT8x64_SPLAT_DEFINED +#endif + +#if !defined(VINT8x64_LOAD_ALIGNED_DEFINED) && defined(VINT8x32_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 64, 32) +# define VINT8x64_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x64_LOAD_DEFINED) && defined(VINT8x32_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 8, 64, 32) +# define VINT8x64_LOAD_DEFINED +#endif + +#if !defined(VINT8x64_STORE_ALIGNED_DEFINED) && defined(VINT8x32_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 64, 32) +# define VINT8x64_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT8x64_STORE_DEFINED) && defined(VINT8x32_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 8, 64, 32) +# define VINT8x64_STORE_DEFINED +#endif + +#if !defined(VINT8x64_ADD_DEFINED) && defined(VINT8x32_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 8, 64, 32) +# define VINT8x64_ADD_DEFINED +#endif + +#if !defined(VINT8x64_SUB_DEFINED) && defined(VINT8x32_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 8, 64, 32) +# define VINT8x64_SUB_DEFINED +#endif + +#if !defined(VINT8x64_MUL_DEFINED) && defined(VINT8x32_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 8, 64, 32) +# define VINT8x64_MUL_DEFINED +#endif + +#if !defined(VINT8x64_DIV_DEFINED) && defined(VINT8x32_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 8, 64, 32) +# define VINT8x64_DIV_DEFINED +#endif + +#if !defined(VINT8x64_MOD_DEFINED) && defined(VINT8x32_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 8, 64, 32) +# define VINT8x64_MOD_DEFINED +#endif + +#if !defined(VINT8x64_AVG_DEFINED) && defined(VINT8x32_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 8, 64, 32) +# define VINT8x64_AVG_DEFINED +#endif + +#if !defined(VINT8x64_AND_DEFINED) && defined(VINT8x32_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 8, 64, 32) +# define VINT8x64_AND_DEFINED +#endif + +#if !defined(VINT8x64_OR_DEFINED) && defined(VINT8x32_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 8, 64, 32) +# define VINT8x64_OR_DEFINED +#endif + +#if !defined(VINT8x64_XOR_DEFINED) && defined(VINT8x32_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 8, 64, 32) +# define VINT8x64_XOR_DEFINED +#endif + +#if !defined(VINT8x64_NOT_DEFINED) && defined(VINT8x32_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 8, 64, 32) +# define VINT8x64_NOT_DEFINED +#endif + +#if !defined(VINT8x64_CMPLT_DEFINED) && defined(VINT8x32_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 8, 64, 32) +# define VINT8x64_CMPLT_DEFINED +#endif + +#if !defined(VINT8x64_CMPEQ_DEFINED) && defined(VINT8x32_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 8, 64, 32) +# define VINT8x64_CMPEQ_DEFINED +#endif + +#if !defined(VINT8x64_CMPGT_DEFINED) && defined(VINT8x32_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 8, 64, 32) +# define VINT8x64_CMPGT_DEFINED +#endif + +#if !defined(VINT8x64_CMPLE_DEFINED) && defined(VINT8x32_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 8, 64, 32) +# define VINT8x64_CMPLE_DEFINED +#endif + +#if !defined(VINT8x64_CMPGE_DEFINED) && defined(VINT8x32_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 8, 64, 32) +# define VINT8x64_CMPGE_DEFINED +#endif + +#if !defined(VINT8x64_MIN_DEFINED) && defined(VINT8x32_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 8, 64, 32) +# define VINT8x64_MIN_DEFINED +#endif + +#if !defined(VINT8x64_MAX_DEFINED) && defined(VINT8x32_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 8, 64, 32) +# define VINT8x64_MAX_DEFINED +#endif + +#if !defined(VINT8x64_RSHIFT_DEFINED) && defined(VINT8x32_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 8, 64, 32) +# define VINT8x64_RSHIFT_DEFINED +#endif + +#if !defined(VINT8x64_LRSHIFT_DEFINED) && defined(VINT8x32_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 64, 32) +# define VINT8x64_LRSHIFT_DEFINED +#endif + +#if !defined(VINT8x64_LSHIFT_DEFINED) && defined(VINT8x32_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 8, 64, 32) +# define VINT8x64_LSHIFT_DEFINED +#endif + + + +/* vint8x64 */ + +#if !defined(VUINT8x64_SPLAT_DEFINED) && defined(VUINT8x32_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 8, 64, 32) +# define VUINT8x64_SPLAT_DEFINED +#endif + +#if !defined(VUINT8x64_LOAD_ALIGNED_DEFINED) && defined(VUINT8x32_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 8, 64, 32) +# define VUINT8x64_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x64_LOAD_DEFINED) && defined(VUINT8x32_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 8, 64, 32) +# define VUINT8x64_LOAD_DEFINED +#endif + +#if !defined(VUINT8x64_STORE_ALIGNED_DEFINED) && defined(VUINT8x32_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 8, 64, 32) +# define VUINT8x64_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT8x64_STORE_DEFINED) && defined(VUINT8x32_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 8, 64, 32) +# define VUINT8x64_STORE_DEFINED +#endif + +#if !defined(VUINT8x64_ADD_DEFINED) && defined(VUINT8x32_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 8, 64, 32) +# define VUINT8x64_ADD_DEFINED +#endif + +#if !defined(VUINT8x64_SUB_DEFINED) && defined(VUINT8x32_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 8, 64, 32) +# define VUINT8x64_SUB_DEFINED +#endif + +#if !defined(VUINT8x64_MUL_DEFINED) && defined(VUINT8x32_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 8, 64, 32) +# define VUINT8x64_MUL_DEFINED +#endif + +#if !defined(VUINT8x64_DIV_DEFINED) && defined(VUINT8x32_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 8, 64, 32) +# define VUINT8x64_DIV_DEFINED +#endif + +#if !defined(VUINT8x64_MOD_DEFINED) && defined(VUINT8x32_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 8, 64, 32) +# define VUINT8x64_MOD_DEFINED +#endif + +#if !defined(VUINT8x64_AVG_DEFINED) && defined(VUINT8x32_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 8, 64, 32) +# define VUINT8x64_AVG_DEFINED +#endif + +#if !defined(VUINT8x64_AND_DEFINED) && defined(VUINT8x32_AND_DEFINED) +VEC_DOUBLE_AND(u, 8, 64, 32) +# define VUINT8x64_AND_DEFINED +#endif + +#if !defined(VUINT8x64_OR_DEFINED) && defined(VUINT8x32_OR_DEFINED) +VEC_DOUBLE_OR(u, 8, 64, 32) +# define VUINT8x64_OR_DEFINED +#endif + +#if !defined(VUINT8x64_XOR_DEFINED) && defined(VUINT8x32_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 8, 64, 32) +# define VUINT8x64_XOR_DEFINED +#endif + +#if !defined(VUINT8x64_NOT_DEFINED) && defined(VUINT8x32_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 8, 64, 32) +# define VUINT8x64_NOT_DEFINED +#endif + +#if !defined(VUINT8x64_CMPLT_DEFINED) && defined(VUINT8x32_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 8, 64, 32) +# define VUINT8x64_CMPLT_DEFINED +#endif + +#if !defined(VUINT8x64_CMPEQ_DEFINED) && defined(VUINT8x32_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 8, 64, 32) +# define VUINT8x64_CMPEQ_DEFINED +#endif + +#if !defined(VUINT8x64_CMPGT_DEFINED) && defined(VUINT8x32_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 8, 64, 32) +# define VUINT8x64_CMPGT_DEFINED +#endif + +#if !defined(VUINT8x64_CMPLE_DEFINED) && defined(VUINT8x32_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 8, 64, 32) +# define VUINT8x64_CMPLE_DEFINED +#endif + +#if !defined(VUINT8x64_CMPGE_DEFINED) && defined(VUINT8x32_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 8, 64, 32) +# define VUINT8x64_CMPGE_DEFINED +#endif + +#if !defined(VUINT8x64_MIN_DEFINED) && defined(VUINT8x32_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 8, 64, 32) +# define VUINT8x64_MIN_DEFINED +#endif + +#if !defined(VUINT8x64_MAX_DEFINED) && defined(VUINT8x32_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 8, 64, 32) +# define VUINT8x64_MAX_DEFINED +#endif + +#if !defined(VUINT8x64_RSHIFT_DEFINED) && defined(VUINT8x32_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 8, 64, 32) +# define VUINT8x64_RSHIFT_DEFINED +#endif + +#if !defined(VUINT8x64_LRSHIFT_DEFINED) && defined(VUINT8x32_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 8, 64, 32) +# define VUINT8x64_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT8x64_LSHIFT_DEFINED) && defined(VUINT8x32_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 8, 64, 32) +# define VUINT8x64_LSHIFT_DEFINED +#endif + + + +/* vuint16x4 */ + +#if !defined(VINT16x4_SPLAT_DEFINED) && defined(VINT16x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 16, 4, 2) +# define VINT16x4_SPLAT_DEFINED +#endif + +#if !defined(VINT16x4_LOAD_ALIGNED_DEFINED) && defined(VINT16x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 4, 2) +# define VINT16x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x4_LOAD_DEFINED) && defined(VINT16x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 16, 4, 2) +# define VINT16x4_LOAD_DEFINED +#endif + +#if !defined(VINT16x4_STORE_ALIGNED_DEFINED) && defined(VINT16x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 4, 2) +# define VINT16x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x4_STORE_DEFINED) && defined(VINT16x2_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 16, 4, 2) +# define VINT16x4_STORE_DEFINED +#endif + +#if !defined(VINT16x4_ADD_DEFINED) && defined(VINT16x2_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 16, 4, 2) +# define VINT16x4_ADD_DEFINED +#endif + +#if !defined(VINT16x4_SUB_DEFINED) && defined(VINT16x2_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 16, 4, 2) +# define VINT16x4_SUB_DEFINED +#endif + +#if !defined(VINT16x4_MUL_DEFINED) && defined(VINT16x2_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 16, 4, 2) +# define VINT16x4_MUL_DEFINED +#endif + +#if !defined(VINT16x4_DIV_DEFINED) && defined(VINT16x2_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 16, 4, 2) +# define VINT16x4_DIV_DEFINED +#endif + +#if !defined(VINT16x4_MOD_DEFINED) && defined(VINT16x2_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 16, 4, 2) +# define VINT16x4_MOD_DEFINED +#endif + +#if !defined(VINT16x4_AVG_DEFINED) && defined(VINT16x2_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 16, 4, 2) +# define VINT16x4_AVG_DEFINED +#endif + +#if !defined(VINT16x4_AND_DEFINED) && defined(VINT16x2_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 16, 4, 2) +# define VINT16x4_AND_DEFINED +#endif + +#if !defined(VINT16x4_OR_DEFINED) && defined(VINT16x2_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 16, 4, 2) +# define VINT16x4_OR_DEFINED +#endif + +#if !defined(VINT16x4_XOR_DEFINED) && defined(VINT16x2_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 16, 4, 2) +# define VINT16x4_XOR_DEFINED +#endif + +#if !defined(VINT16x4_NOT_DEFINED) && defined(VINT16x2_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 16, 4, 2) +# define VINT16x4_NOT_DEFINED +#endif + +#if !defined(VINT16x4_CMPLT_DEFINED) && defined(VINT16x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 16, 4, 2) +# define VINT16x4_CMPLT_DEFINED +#endif + +#if !defined(VINT16x4_CMPEQ_DEFINED) && defined(VINT16x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 16, 4, 2) +# define VINT16x4_CMPEQ_DEFINED +#endif + +#if !defined(VINT16x4_CMPGT_DEFINED) && defined(VINT16x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 16, 4, 2) +# define VINT16x4_CMPGT_DEFINED +#endif + +#if !defined(VINT16x4_CMPLE_DEFINED) && defined(VINT16x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 16, 4, 2) +# define VINT16x4_CMPLE_DEFINED +#endif + +#if !defined(VINT16x4_CMPGE_DEFINED) && defined(VINT16x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 16, 4, 2) +# define VINT16x4_CMPGE_DEFINED +#endif + +#if !defined(VINT16x4_MIN_DEFINED) && defined(VINT16x2_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 16, 4, 2) +# define VINT16x4_MIN_DEFINED +#endif + +#if !defined(VINT16x4_MAX_DEFINED) && defined(VINT16x2_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 16, 4, 2) +# define VINT16x4_MAX_DEFINED +#endif + +#if !defined(VINT16x4_RSHIFT_DEFINED) && defined(VINT16x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 16, 4, 2) +# define VINT16x4_RSHIFT_DEFINED +#endif + +#if !defined(VINT16x4_LRSHIFT_DEFINED) && defined(VINT16x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 4, 2) +# define VINT16x4_LRSHIFT_DEFINED +#endif + +#if !defined(VINT16x4_LSHIFT_DEFINED) && defined(VINT16x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 16, 4, 2) +# define VINT16x4_LSHIFT_DEFINED +#endif + + + +/* vint16x4 */ + +#if !defined(VUINT16x4_SPLAT_DEFINED) && defined(VUINT16x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 16, 4, 2) +# define VUINT16x4_SPLAT_DEFINED +#endif + +#if !defined(VUINT16x4_LOAD_ALIGNED_DEFINED) && defined(VUINT16x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 16, 4, 2) +# define VUINT16x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x4_LOAD_DEFINED) && defined(VUINT16x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 16, 4, 2) +# define VUINT16x4_LOAD_DEFINED +#endif + +#if !defined(VUINT16x4_STORE_ALIGNED_DEFINED) && defined(VUINT16x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 16, 4, 2) +# define VUINT16x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x4_STORE_DEFINED) && defined(VUINT16x2_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 16, 4, 2) +# define VUINT16x4_STORE_DEFINED +#endif + +#if !defined(VUINT16x4_ADD_DEFINED) && defined(VUINT16x2_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 16, 4, 2) +# define VUINT16x4_ADD_DEFINED +#endif + +#if !defined(VUINT16x4_SUB_DEFINED) && defined(VUINT16x2_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 16, 4, 2) +# define VUINT16x4_SUB_DEFINED +#endif + +#if !defined(VUINT16x4_MUL_DEFINED) && defined(VUINT16x2_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 16, 4, 2) +# define VUINT16x4_MUL_DEFINED +#endif + +#if !defined(VUINT16x4_DIV_DEFINED) && defined(VUINT16x2_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 16, 4, 2) +# define VUINT16x4_DIV_DEFINED +#endif + +#if !defined(VUINT16x4_MOD_DEFINED) && defined(VUINT16x2_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 16, 4, 2) +# define VUINT16x4_MOD_DEFINED +#endif + +#if !defined(VUINT16x4_AVG_DEFINED) && defined(VUINT16x2_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 16, 4, 2) +# define VUINT16x4_AVG_DEFINED +#endif + +#if !defined(VUINT16x4_AND_DEFINED) && defined(VUINT16x2_AND_DEFINED) +VEC_DOUBLE_AND(u, 16, 4, 2) +# define VUINT16x4_AND_DEFINED +#endif + +#if !defined(VUINT16x4_OR_DEFINED) && defined(VUINT16x2_OR_DEFINED) +VEC_DOUBLE_OR(u, 16, 4, 2) +# define VUINT16x4_OR_DEFINED +#endif + +#if !defined(VUINT16x4_XOR_DEFINED) && defined(VUINT16x2_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 16, 4, 2) +# define VUINT16x4_XOR_DEFINED +#endif + +#if !defined(VUINT16x4_NOT_DEFINED) && defined(VUINT16x2_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 16, 4, 2) +# define VUINT16x4_NOT_DEFINED +#endif + +#if !defined(VUINT16x4_CMPLT_DEFINED) && defined(VUINT16x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 16, 4, 2) +# define VUINT16x4_CMPLT_DEFINED +#endif + +#if !defined(VUINT16x4_CMPEQ_DEFINED) && defined(VUINT16x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 16, 4, 2) +# define VUINT16x4_CMPEQ_DEFINED +#endif + +#if !defined(VUINT16x4_CMPGT_DEFINED) && defined(VUINT16x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 16, 4, 2) +# define VUINT16x4_CMPGT_DEFINED +#endif + +#if !defined(VUINT16x4_CMPLE_DEFINED) && defined(VUINT16x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 16, 4, 2) +# define VUINT16x4_CMPLE_DEFINED +#endif + +#if !defined(VUINT16x4_CMPGE_DEFINED) && defined(VUINT16x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 16, 4, 2) +# define VUINT16x4_CMPGE_DEFINED +#endif + +#if !defined(VUINT16x4_MIN_DEFINED) && defined(VUINT16x2_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 16, 4, 2) +# define VUINT16x4_MIN_DEFINED +#endif + +#if !defined(VUINT16x4_MAX_DEFINED) && defined(VUINT16x2_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 16, 4, 2) +# define VUINT16x4_MAX_DEFINED +#endif + +#if !defined(VUINT16x4_RSHIFT_DEFINED) && defined(VUINT16x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 16, 4, 2) +# define VUINT16x4_RSHIFT_DEFINED +#endif + +#if !defined(VUINT16x4_LRSHIFT_DEFINED) && defined(VUINT16x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 16, 4, 2) +# define VUINT16x4_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT16x4_LSHIFT_DEFINED) && defined(VUINT16x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 16, 4, 2) +# define VUINT16x4_LSHIFT_DEFINED +#endif + + + +/* vuint16x8 */ + +#if !defined(VINT16x8_SPLAT_DEFINED) && defined(VINT16x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 16, 8, 4) +# define VINT16x8_SPLAT_DEFINED +#endif + +#if !defined(VINT16x8_LOAD_ALIGNED_DEFINED) && defined(VINT16x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 8, 4) +# define VINT16x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x8_LOAD_DEFINED) && defined(VINT16x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 16, 8, 4) +# define VINT16x8_LOAD_DEFINED +#endif + +#if !defined(VINT16x8_STORE_ALIGNED_DEFINED) && defined(VINT16x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 8, 4) +# define VINT16x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x8_STORE_DEFINED) && defined(VINT16x4_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 16, 8, 4) +# define VINT16x8_STORE_DEFINED +#endif + +#if !defined(VINT16x8_ADD_DEFINED) && defined(VINT16x4_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 16, 8, 4) +# define VINT16x8_ADD_DEFINED +#endif + +#if !defined(VINT16x8_SUB_DEFINED) && defined(VINT16x4_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 16, 8, 4) +# define VINT16x8_SUB_DEFINED +#endif + +#if !defined(VINT16x8_MUL_DEFINED) && defined(VINT16x4_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 16, 8, 4) +# define VINT16x8_MUL_DEFINED +#endif + +#if !defined(VINT16x8_DIV_DEFINED) && defined(VINT16x4_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 16, 8, 4) +# define VINT16x8_DIV_DEFINED +#endif + +#if !defined(VINT16x8_MOD_DEFINED) && defined(VINT16x4_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 16, 8, 4) +# define VINT16x8_MOD_DEFINED +#endif + +#if !defined(VINT16x8_AVG_DEFINED) && defined(VINT16x4_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 16, 8, 4) +# define VINT16x8_AVG_DEFINED +#endif + +#if !defined(VINT16x8_AND_DEFINED) && defined(VINT16x4_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 16, 8, 4) +# define VINT16x8_AND_DEFINED +#endif + +#if !defined(VINT16x8_OR_DEFINED) && defined(VINT16x4_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 16, 8, 4) +# define VINT16x8_OR_DEFINED +#endif + +#if !defined(VINT16x8_XOR_DEFINED) && defined(VINT16x4_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 16, 8, 4) +# define VINT16x8_XOR_DEFINED +#endif + +#if !defined(VINT16x8_NOT_DEFINED) && defined(VINT16x4_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 16, 8, 4) +# define VINT16x8_NOT_DEFINED +#endif + +#if !defined(VINT16x8_CMPLT_DEFINED) && defined(VINT16x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 16, 8, 4) +# define VINT16x8_CMPLT_DEFINED +#endif + +#if !defined(VINT16x8_CMPEQ_DEFINED) && defined(VINT16x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 16, 8, 4) +# define VINT16x8_CMPEQ_DEFINED +#endif + +#if !defined(VINT16x8_CMPGT_DEFINED) && defined(VINT16x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 16, 8, 4) +# define VINT16x8_CMPGT_DEFINED +#endif + +#if !defined(VINT16x8_CMPLE_DEFINED) && defined(VINT16x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 16, 8, 4) +# define VINT16x8_CMPLE_DEFINED +#endif + +#if !defined(VINT16x8_CMPGE_DEFINED) && defined(VINT16x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 16, 8, 4) +# define VINT16x8_CMPGE_DEFINED +#endif + +#if !defined(VINT16x8_MIN_DEFINED) && defined(VINT16x4_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 16, 8, 4) +# define VINT16x8_MIN_DEFINED +#endif + +#if !defined(VINT16x8_MAX_DEFINED) && defined(VINT16x4_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 16, 8, 4) +# define VINT16x8_MAX_DEFINED +#endif + +#if !defined(VINT16x8_RSHIFT_DEFINED) && defined(VINT16x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 16, 8, 4) +# define VINT16x8_RSHIFT_DEFINED +#endif + +#if !defined(VINT16x8_LRSHIFT_DEFINED) && defined(VINT16x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 8, 4) +# define VINT16x8_LRSHIFT_DEFINED +#endif + +#if !defined(VINT16x8_LSHIFT_DEFINED) && defined(VINT16x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 16, 8, 4) +# define VINT16x8_LSHIFT_DEFINED +#endif + + + +/* vint16x8 */ + +#if !defined(VUINT16x8_SPLAT_DEFINED) && defined(VUINT16x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 16, 8, 4) +# define VUINT16x8_SPLAT_DEFINED +#endif + +#if !defined(VUINT16x8_LOAD_ALIGNED_DEFINED) && defined(VUINT16x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 16, 8, 4) +# define VUINT16x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x8_LOAD_DEFINED) && defined(VUINT16x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 16, 8, 4) +# define VUINT16x8_LOAD_DEFINED +#endif + +#if !defined(VUINT16x8_STORE_ALIGNED_DEFINED) && defined(VUINT16x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 16, 8, 4) +# define VUINT16x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x8_STORE_DEFINED) && defined(VUINT16x4_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 16, 8, 4) +# define VUINT16x8_STORE_DEFINED +#endif + +#if !defined(VUINT16x8_ADD_DEFINED) && defined(VUINT16x4_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 16, 8, 4) +# define VUINT16x8_ADD_DEFINED +#endif + +#if !defined(VUINT16x8_SUB_DEFINED) && defined(VUINT16x4_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 16, 8, 4) +# define VUINT16x8_SUB_DEFINED +#endif + +#if !defined(VUINT16x8_MUL_DEFINED) && defined(VUINT16x4_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 16, 8, 4) +# define VUINT16x8_MUL_DEFINED +#endif + +#if !defined(VUINT16x8_DIV_DEFINED) && defined(VUINT16x4_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 16, 8, 4) +# define VUINT16x8_DIV_DEFINED +#endif + +#if !defined(VUINT16x8_MOD_DEFINED) && defined(VUINT16x4_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 16, 8, 4) +# define VUINT16x8_MOD_DEFINED +#endif + +#if !defined(VUINT16x8_AVG_DEFINED) && defined(VUINT16x4_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 16, 8, 4) +# define VUINT16x8_AVG_DEFINED +#endif + +#if !defined(VUINT16x8_AND_DEFINED) && defined(VUINT16x4_AND_DEFINED) +VEC_DOUBLE_AND(u, 16, 8, 4) +# define VUINT16x8_AND_DEFINED +#endif + +#if !defined(VUINT16x8_OR_DEFINED) && defined(VUINT16x4_OR_DEFINED) +VEC_DOUBLE_OR(u, 16, 8, 4) +# define VUINT16x8_OR_DEFINED +#endif + +#if !defined(VUINT16x8_XOR_DEFINED) && defined(VUINT16x4_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 16, 8, 4) +# define VUINT16x8_XOR_DEFINED +#endif + +#if !defined(VUINT16x8_NOT_DEFINED) && defined(VUINT16x4_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 16, 8, 4) +# define VUINT16x8_NOT_DEFINED +#endif + +#if !defined(VUINT16x8_CMPLT_DEFINED) && defined(VUINT16x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 16, 8, 4) +# define VUINT16x8_CMPLT_DEFINED +#endif + +#if !defined(VUINT16x8_CMPEQ_DEFINED) && defined(VUINT16x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 16, 8, 4) +# define VUINT16x8_CMPEQ_DEFINED +#endif + +#if !defined(VUINT16x8_CMPGT_DEFINED) && defined(VUINT16x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 16, 8, 4) +# define VUINT16x8_CMPGT_DEFINED +#endif + +#if !defined(VUINT16x8_CMPLE_DEFINED) && defined(VUINT16x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 16, 8, 4) +# define VUINT16x8_CMPLE_DEFINED +#endif + +#if !defined(VUINT16x8_CMPGE_DEFINED) && defined(VUINT16x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 16, 8, 4) +# define VUINT16x8_CMPGE_DEFINED +#endif + +#if !defined(VUINT16x8_MIN_DEFINED) && defined(VUINT16x4_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 16, 8, 4) +# define VUINT16x8_MIN_DEFINED +#endif + +#if !defined(VUINT16x8_MAX_DEFINED) && defined(VUINT16x4_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 16, 8, 4) +# define VUINT16x8_MAX_DEFINED +#endif + +#if !defined(VUINT16x8_RSHIFT_DEFINED) && defined(VUINT16x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 16, 8, 4) +# define VUINT16x8_RSHIFT_DEFINED +#endif + +#if !defined(VUINT16x8_LRSHIFT_DEFINED) && defined(VUINT16x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 16, 8, 4) +# define VUINT16x8_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT16x8_LSHIFT_DEFINED) && defined(VUINT16x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 16, 8, 4) +# define VUINT16x8_LSHIFT_DEFINED +#endif + + + +/* vuint16x16 */ + +#if !defined(VINT16x16_SPLAT_DEFINED) && defined(VINT16x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 16, 16, 8) +# define VINT16x16_SPLAT_DEFINED +#endif + +#if !defined(VINT16x16_LOAD_ALIGNED_DEFINED) && defined(VINT16x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 16, 8) +# define VINT16x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x16_LOAD_DEFINED) && defined(VINT16x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 16, 16, 8) +# define VINT16x16_LOAD_DEFINED +#endif + +#if !defined(VINT16x16_STORE_ALIGNED_DEFINED) && defined(VINT16x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 16, 8) +# define VINT16x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x16_STORE_DEFINED) && defined(VINT16x8_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 16, 16, 8) +# define VINT16x16_STORE_DEFINED +#endif + +#if !defined(VINT16x16_ADD_DEFINED) && defined(VINT16x8_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 16, 16, 8) +# define VINT16x16_ADD_DEFINED +#endif + +#if !defined(VINT16x16_SUB_DEFINED) && defined(VINT16x8_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 16, 16, 8) +# define VINT16x16_SUB_DEFINED +#endif + +#if !defined(VINT16x16_MUL_DEFINED) && defined(VINT16x8_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 16, 16, 8) +# define VINT16x16_MUL_DEFINED +#endif + +#if !defined(VINT16x16_DIV_DEFINED) && defined(VINT16x8_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 16, 16, 8) +# define VINT16x16_DIV_DEFINED +#endif + +#if !defined(VINT16x16_MOD_DEFINED) && defined(VINT16x8_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 16, 16, 8) +# define VINT16x16_MOD_DEFINED +#endif + +#if !defined(VINT16x16_AVG_DEFINED) && defined(VINT16x8_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 16, 16, 8) +# define VINT16x16_AVG_DEFINED +#endif + +#if !defined(VINT16x16_AND_DEFINED) && defined(VINT16x8_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 16, 16, 8) +# define VINT16x16_AND_DEFINED +#endif + +#if !defined(VINT16x16_OR_DEFINED) && defined(VINT16x8_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 16, 16, 8) +# define VINT16x16_OR_DEFINED +#endif + +#if !defined(VINT16x16_XOR_DEFINED) && defined(VINT16x8_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 16, 16, 8) +# define VINT16x16_XOR_DEFINED +#endif + +#if !defined(VINT16x16_NOT_DEFINED) && defined(VINT16x8_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 16, 16, 8) +# define VINT16x16_NOT_DEFINED +#endif + +#if !defined(VINT16x16_CMPLT_DEFINED) && defined(VINT16x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 16, 16, 8) +# define VINT16x16_CMPLT_DEFINED +#endif + +#if !defined(VINT16x16_CMPEQ_DEFINED) && defined(VINT16x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 16, 16, 8) +# define VINT16x16_CMPEQ_DEFINED +#endif + +#if !defined(VINT16x16_CMPGT_DEFINED) && defined(VINT16x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 16, 16, 8) +# define VINT16x16_CMPGT_DEFINED +#endif + +#if !defined(VINT16x16_CMPLE_DEFINED) && defined(VINT16x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 16, 16, 8) +# define VINT16x16_CMPLE_DEFINED +#endif + +#if !defined(VINT16x16_CMPGE_DEFINED) && defined(VINT16x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 16, 16, 8) +# define VINT16x16_CMPGE_DEFINED +#endif + +#if !defined(VINT16x16_MIN_DEFINED) && defined(VINT16x8_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 16, 16, 8) +# define VINT16x16_MIN_DEFINED +#endif + +#if !defined(VINT16x16_MAX_DEFINED) && defined(VINT16x8_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 16, 16, 8) +# define VINT16x16_MAX_DEFINED +#endif + +#if !defined(VINT16x16_RSHIFT_DEFINED) && defined(VINT16x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 16, 16, 8) +# define VINT16x16_RSHIFT_DEFINED +#endif + +#if !defined(VINT16x16_LRSHIFT_DEFINED) && defined(VINT16x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 16, 8) +# define VINT16x16_LRSHIFT_DEFINED +#endif + +#if !defined(VINT16x16_LSHIFT_DEFINED) && defined(VINT16x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 16, 16, 8) +# define VINT16x16_LSHIFT_DEFINED +#endif + + + +/* vint16x16 */ + +#if !defined(VUINT16x16_SPLAT_DEFINED) && defined(VUINT16x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 16, 16, 8) +# define VUINT16x16_SPLAT_DEFINED +#endif + +#if !defined(VUINT16x16_LOAD_ALIGNED_DEFINED) && defined(VUINT16x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 16, 16, 8) +# define VUINT16x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x16_LOAD_DEFINED) && defined(VUINT16x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 16, 16, 8) +# define VUINT16x16_LOAD_DEFINED +#endif + +#if !defined(VUINT16x16_STORE_ALIGNED_DEFINED) && defined(VUINT16x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 16, 16, 8) +# define VUINT16x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x16_STORE_DEFINED) && defined(VUINT16x8_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 16, 16, 8) +# define VUINT16x16_STORE_DEFINED +#endif + +#if !defined(VUINT16x16_ADD_DEFINED) && defined(VUINT16x8_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 16, 16, 8) +# define VUINT16x16_ADD_DEFINED +#endif + +#if !defined(VUINT16x16_SUB_DEFINED) && defined(VUINT16x8_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 16, 16, 8) +# define VUINT16x16_SUB_DEFINED +#endif + +#if !defined(VUINT16x16_MUL_DEFINED) && defined(VUINT16x8_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 16, 16, 8) +# define VUINT16x16_MUL_DEFINED +#endif + +#if !defined(VUINT16x16_DIV_DEFINED) && defined(VUINT16x8_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 16, 16, 8) +# define VUINT16x16_DIV_DEFINED +#endif + +#if !defined(VUINT16x16_MOD_DEFINED) && defined(VUINT16x8_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 16, 16, 8) +# define VUINT16x16_MOD_DEFINED +#endif + +#if !defined(VUINT16x16_AVG_DEFINED) && defined(VUINT16x8_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 16, 16, 8) +# define VUINT16x16_AVG_DEFINED +#endif + +#if !defined(VUINT16x16_AND_DEFINED) && defined(VUINT16x8_AND_DEFINED) +VEC_DOUBLE_AND(u, 16, 16, 8) +# define VUINT16x16_AND_DEFINED +#endif + +#if !defined(VUINT16x16_OR_DEFINED) && defined(VUINT16x8_OR_DEFINED) +VEC_DOUBLE_OR(u, 16, 16, 8) +# define VUINT16x16_OR_DEFINED +#endif + +#if !defined(VUINT16x16_XOR_DEFINED) && defined(VUINT16x8_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 16, 16, 8) +# define VUINT16x16_XOR_DEFINED +#endif + +#if !defined(VUINT16x16_NOT_DEFINED) && defined(VUINT16x8_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 16, 16, 8) +# define VUINT16x16_NOT_DEFINED +#endif + +#if !defined(VUINT16x16_CMPLT_DEFINED) && defined(VUINT16x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 16, 16, 8) +# define VUINT16x16_CMPLT_DEFINED +#endif + +#if !defined(VUINT16x16_CMPEQ_DEFINED) && defined(VUINT16x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 16, 16, 8) +# define VUINT16x16_CMPEQ_DEFINED +#endif + +#if !defined(VUINT16x16_CMPGT_DEFINED) && defined(VUINT16x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 16, 16, 8) +# define VUINT16x16_CMPGT_DEFINED +#endif + +#if !defined(VUINT16x16_CMPLE_DEFINED) && defined(VUINT16x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 16, 16, 8) +# define VUINT16x16_CMPLE_DEFINED +#endif + +#if !defined(VUINT16x16_CMPGE_DEFINED) && defined(VUINT16x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 16, 16, 8) +# define VUINT16x16_CMPGE_DEFINED +#endif + +#if !defined(VUINT16x16_MIN_DEFINED) && defined(VUINT16x8_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 16, 16, 8) +# define VUINT16x16_MIN_DEFINED +#endif + +#if !defined(VUINT16x16_MAX_DEFINED) && defined(VUINT16x8_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 16, 16, 8) +# define VUINT16x16_MAX_DEFINED +#endif + +#if !defined(VUINT16x16_RSHIFT_DEFINED) && defined(VUINT16x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 16, 16, 8) +# define VUINT16x16_RSHIFT_DEFINED +#endif + +#if !defined(VUINT16x16_LRSHIFT_DEFINED) && defined(VUINT16x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 16, 16, 8) +# define VUINT16x16_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT16x16_LSHIFT_DEFINED) && defined(VUINT16x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 16, 16, 8) +# define VUINT16x16_LSHIFT_DEFINED +#endif + + + +/* vuint16x32 */ + +#if !defined(VINT16x32_SPLAT_DEFINED) && defined(VINT16x16_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 16, 32, 16) +# define VINT16x32_SPLAT_DEFINED +#endif + +#if !defined(VINT16x32_LOAD_ALIGNED_DEFINED) && defined(VINT16x16_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 32, 16) +# define VINT16x32_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x32_LOAD_DEFINED) && defined(VINT16x16_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 16, 32, 16) +# define VINT16x32_LOAD_DEFINED +#endif + +#if !defined(VINT16x32_STORE_ALIGNED_DEFINED) && defined(VINT16x16_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 32, 16) +# define VINT16x32_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT16x32_STORE_DEFINED) && defined(VINT16x16_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 16, 32, 16) +# define VINT16x32_STORE_DEFINED +#endif + +#if !defined(VINT16x32_ADD_DEFINED) && defined(VINT16x16_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 16, 32, 16) +# define VINT16x32_ADD_DEFINED +#endif + +#if !defined(VINT16x32_SUB_DEFINED) && defined(VINT16x16_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 16, 32, 16) +# define VINT16x32_SUB_DEFINED +#endif + +#if !defined(VINT16x32_MUL_DEFINED) && defined(VINT16x16_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 16, 32, 16) +# define VINT16x32_MUL_DEFINED +#endif + +#if !defined(VINT16x32_DIV_DEFINED) && defined(VINT16x16_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 16, 32, 16) +# define VINT16x32_DIV_DEFINED +#endif + +#if !defined(VINT16x32_MOD_DEFINED) && defined(VINT16x16_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 16, 32, 16) +# define VINT16x32_MOD_DEFINED +#endif + +#if !defined(VINT16x32_AVG_DEFINED) && defined(VINT16x16_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 16, 32, 16) +# define VINT16x32_AVG_DEFINED +#endif + +#if !defined(VINT16x32_AND_DEFINED) && defined(VINT16x16_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 16, 32, 16) +# define VINT16x32_AND_DEFINED +#endif + +#if !defined(VINT16x32_OR_DEFINED) && defined(VINT16x16_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 16, 32, 16) +# define VINT16x32_OR_DEFINED +#endif + +#if !defined(VINT16x32_XOR_DEFINED) && defined(VINT16x16_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 16, 32, 16) +# define VINT16x32_XOR_DEFINED +#endif + +#if !defined(VINT16x32_NOT_DEFINED) && defined(VINT16x16_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 16, 32, 16) +# define VINT16x32_NOT_DEFINED +#endif + +#if !defined(VINT16x32_CMPLT_DEFINED) && defined(VINT16x16_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 16, 32, 16) +# define VINT16x32_CMPLT_DEFINED +#endif + +#if !defined(VINT16x32_CMPEQ_DEFINED) && defined(VINT16x16_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 16, 32, 16) +# define VINT16x32_CMPEQ_DEFINED +#endif + +#if !defined(VINT16x32_CMPGT_DEFINED) && defined(VINT16x16_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 16, 32, 16) +# define VINT16x32_CMPGT_DEFINED +#endif + +#if !defined(VINT16x32_CMPLE_DEFINED) && defined(VINT16x16_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 16, 32, 16) +# define VINT16x32_CMPLE_DEFINED +#endif + +#if !defined(VINT16x32_CMPGE_DEFINED) && defined(VINT16x16_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 16, 32, 16) +# define VINT16x32_CMPGE_DEFINED +#endif + +#if !defined(VINT16x32_MIN_DEFINED) && defined(VINT16x16_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 16, 32, 16) +# define VINT16x32_MIN_DEFINED +#endif + +#if !defined(VINT16x32_MAX_DEFINED) && defined(VINT16x16_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 16, 32, 16) +# define VINT16x32_MAX_DEFINED +#endif + +#if !defined(VINT16x32_RSHIFT_DEFINED) && defined(VINT16x16_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 16, 32, 16) +# define VINT16x32_RSHIFT_DEFINED +#endif + +#if !defined(VINT16x32_LRSHIFT_DEFINED) && defined(VINT16x16_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 32, 16) +# define VINT16x32_LRSHIFT_DEFINED +#endif + +#if !defined(VINT16x32_LSHIFT_DEFINED) && defined(VINT16x16_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 16, 32, 16) +# define VINT16x32_LSHIFT_DEFINED +#endif + + + +/* vint16x32 */ + +#if !defined(VUINT16x32_SPLAT_DEFINED) && defined(VUINT16x16_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 16, 32, 16) +# define VUINT16x32_SPLAT_DEFINED +#endif + +#if !defined(VUINT16x32_LOAD_ALIGNED_DEFINED) && defined(VUINT16x16_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 16, 32, 16) +# define VUINT16x32_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x32_LOAD_DEFINED) && defined(VUINT16x16_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 16, 32, 16) +# define VUINT16x32_LOAD_DEFINED +#endif + +#if !defined(VUINT16x32_STORE_ALIGNED_DEFINED) && defined(VUINT16x16_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 16, 32, 16) +# define VUINT16x32_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT16x32_STORE_DEFINED) && defined(VUINT16x16_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 16, 32, 16) +# define VUINT16x32_STORE_DEFINED +#endif + +#if !defined(VUINT16x32_ADD_DEFINED) && defined(VUINT16x16_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 16, 32, 16) +# define VUINT16x32_ADD_DEFINED +#endif + +#if !defined(VUINT16x32_SUB_DEFINED) && defined(VUINT16x16_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 16, 32, 16) +# define VUINT16x32_SUB_DEFINED +#endif + +#if !defined(VUINT16x32_MUL_DEFINED) && defined(VUINT16x16_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 16, 32, 16) +# define VUINT16x32_MUL_DEFINED +#endif + +#if !defined(VUINT16x32_DIV_DEFINED) && defined(VUINT16x16_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 16, 32, 16) +# define VUINT16x32_DIV_DEFINED +#endif + +#if !defined(VUINT16x32_MOD_DEFINED) && defined(VUINT16x16_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 16, 32, 16) +# define VUINT16x32_MOD_DEFINED +#endif + +#if !defined(VUINT16x32_AVG_DEFINED) && defined(VUINT16x16_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 16, 32, 16) +# define VUINT16x32_AVG_DEFINED +#endif + +#if !defined(VUINT16x32_AND_DEFINED) && defined(VUINT16x16_AND_DEFINED) +VEC_DOUBLE_AND(u, 16, 32, 16) +# define VUINT16x32_AND_DEFINED +#endif + +#if !defined(VUINT16x32_OR_DEFINED) && defined(VUINT16x16_OR_DEFINED) +VEC_DOUBLE_OR(u, 16, 32, 16) +# define VUINT16x32_OR_DEFINED +#endif + +#if !defined(VUINT16x32_XOR_DEFINED) && defined(VUINT16x16_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 16, 32, 16) +# define VUINT16x32_XOR_DEFINED +#endif + +#if !defined(VUINT16x32_NOT_DEFINED) && defined(VUINT16x16_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 16, 32, 16) +# define VUINT16x32_NOT_DEFINED +#endif + +#if !defined(VUINT16x32_CMPLT_DEFINED) && defined(VUINT16x16_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 16, 32, 16) +# define VUINT16x32_CMPLT_DEFINED +#endif + +#if !defined(VUINT16x32_CMPEQ_DEFINED) && defined(VUINT16x16_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 16, 32, 16) +# define VUINT16x32_CMPEQ_DEFINED +#endif + +#if !defined(VUINT16x32_CMPGT_DEFINED) && defined(VUINT16x16_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 16, 32, 16) +# define VUINT16x32_CMPGT_DEFINED +#endif + +#if !defined(VUINT16x32_CMPLE_DEFINED) && defined(VUINT16x16_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 16, 32, 16) +# define VUINT16x32_CMPLE_DEFINED +#endif + +#if !defined(VUINT16x32_CMPGE_DEFINED) && defined(VUINT16x16_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 16, 32, 16) +# define VUINT16x32_CMPGE_DEFINED +#endif + +#if !defined(VUINT16x32_MIN_DEFINED) && defined(VUINT16x16_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 16, 32, 16) +# define VUINT16x32_MIN_DEFINED +#endif + +#if !defined(VUINT16x32_MAX_DEFINED) && defined(VUINT16x16_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 16, 32, 16) +# define VUINT16x32_MAX_DEFINED +#endif + +#if !defined(VUINT16x32_RSHIFT_DEFINED) && defined(VUINT16x16_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 16, 32, 16) +# define VUINT16x32_RSHIFT_DEFINED +#endif + +#if !defined(VUINT16x32_LRSHIFT_DEFINED) && defined(VUINT16x16_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 16, 32, 16) +# define VUINT16x32_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT16x32_LSHIFT_DEFINED) && defined(VUINT16x16_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 16, 32, 16) +# define VUINT16x32_LSHIFT_DEFINED +#endif + + + +/* vuint32x4 */ + +#if !defined(VINT32x4_SPLAT_DEFINED) && defined(VINT32x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 32, 4, 2) +# define VINT32x4_SPLAT_DEFINED +#endif + +#if !defined(VINT32x4_LOAD_ALIGNED_DEFINED) && defined(VINT32x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 4, 2) +# define VINT32x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x4_LOAD_DEFINED) && defined(VINT32x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 32, 4, 2) +# define VINT32x4_LOAD_DEFINED +#endif + +#if !defined(VINT32x4_STORE_ALIGNED_DEFINED) && defined(VINT32x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 4, 2) +# define VINT32x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x4_STORE_DEFINED) && defined(VINT32x2_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 32, 4, 2) +# define VINT32x4_STORE_DEFINED +#endif + +#if !defined(VINT32x4_ADD_DEFINED) && defined(VINT32x2_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 32, 4, 2) +# define VINT32x4_ADD_DEFINED +#endif + +#if !defined(VINT32x4_SUB_DEFINED) && defined(VINT32x2_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 32, 4, 2) +# define VINT32x4_SUB_DEFINED +#endif + +#if !defined(VINT32x4_MUL_DEFINED) && defined(VINT32x2_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 32, 4, 2) +# define VINT32x4_MUL_DEFINED +#endif + +#if !defined(VINT32x4_DIV_DEFINED) && defined(VINT32x2_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 32, 4, 2) +# define VINT32x4_DIV_DEFINED +#endif + +#if !defined(VINT32x4_MOD_DEFINED) && defined(VINT32x2_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 32, 4, 2) +# define VINT32x4_MOD_DEFINED +#endif + +#if !defined(VINT32x4_AVG_DEFINED) && defined(VINT32x2_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 32, 4, 2) +# define VINT32x4_AVG_DEFINED +#endif + +#if !defined(VINT32x4_AND_DEFINED) && defined(VINT32x2_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 32, 4, 2) +# define VINT32x4_AND_DEFINED +#endif + +#if !defined(VINT32x4_OR_DEFINED) && defined(VINT32x2_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 32, 4, 2) +# define VINT32x4_OR_DEFINED +#endif + +#if !defined(VINT32x4_XOR_DEFINED) && defined(VINT32x2_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 32, 4, 2) +# define VINT32x4_XOR_DEFINED +#endif + +#if !defined(VINT32x4_NOT_DEFINED) && defined(VINT32x2_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 32, 4, 2) +# define VINT32x4_NOT_DEFINED +#endif + +#if !defined(VINT32x4_CMPLT_DEFINED) && defined(VINT32x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 32, 4, 2) +# define VINT32x4_CMPLT_DEFINED +#endif + +#if !defined(VINT32x4_CMPEQ_DEFINED) && defined(VINT32x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 32, 4, 2) +# define VINT32x4_CMPEQ_DEFINED +#endif + +#if !defined(VINT32x4_CMPGT_DEFINED) && defined(VINT32x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 32, 4, 2) +# define VINT32x4_CMPGT_DEFINED +#endif + +#if !defined(VINT32x4_CMPLE_DEFINED) && defined(VINT32x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 32, 4, 2) +# define VINT32x4_CMPLE_DEFINED +#endif + +#if !defined(VINT32x4_CMPGE_DEFINED) && defined(VINT32x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 32, 4, 2) +# define VINT32x4_CMPGE_DEFINED +#endif + +#if !defined(VINT32x4_MIN_DEFINED) && defined(VINT32x2_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 32, 4, 2) +# define VINT32x4_MIN_DEFINED +#endif + +#if !defined(VINT32x4_MAX_DEFINED) && defined(VINT32x2_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 32, 4, 2) +# define VINT32x4_MAX_DEFINED +#endif + +#if !defined(VINT32x4_RSHIFT_DEFINED) && defined(VINT32x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 32, 4, 2) +# define VINT32x4_RSHIFT_DEFINED +#endif + +#if !defined(VINT32x4_LRSHIFT_DEFINED) && defined(VINT32x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 4, 2) +# define VINT32x4_LRSHIFT_DEFINED +#endif + +#if !defined(VINT32x4_LSHIFT_DEFINED) && defined(VINT32x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 32, 4, 2) +# define VINT32x4_LSHIFT_DEFINED +#endif + + + +/* vint32x4 */ + +#if !defined(VUINT32x4_SPLAT_DEFINED) && defined(VUINT32x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 32, 4, 2) +# define VUINT32x4_SPLAT_DEFINED +#endif + +#if !defined(VUINT32x4_LOAD_ALIGNED_DEFINED) && defined(VUINT32x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 32, 4, 2) +# define VUINT32x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x4_LOAD_DEFINED) && defined(VUINT32x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 32, 4, 2) +# define VUINT32x4_LOAD_DEFINED +#endif + +#if !defined(VUINT32x4_STORE_ALIGNED_DEFINED) && defined(VUINT32x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 32, 4, 2) +# define VUINT32x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x4_STORE_DEFINED) && defined(VUINT32x2_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 32, 4, 2) +# define VUINT32x4_STORE_DEFINED +#endif + +#if !defined(VUINT32x4_ADD_DEFINED) && defined(VUINT32x2_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 32, 4, 2) +# define VUINT32x4_ADD_DEFINED +#endif + +#if !defined(VUINT32x4_SUB_DEFINED) && defined(VUINT32x2_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 32, 4, 2) +# define VUINT32x4_SUB_DEFINED +#endif + +#if !defined(VUINT32x4_MUL_DEFINED) && defined(VUINT32x2_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 32, 4, 2) +# define VUINT32x4_MUL_DEFINED +#endif + +#if !defined(VUINT32x4_DIV_DEFINED) && defined(VUINT32x2_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 32, 4, 2) +# define VUINT32x4_DIV_DEFINED +#endif + +#if !defined(VUINT32x4_MOD_DEFINED) && defined(VUINT32x2_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 32, 4, 2) +# define VUINT32x4_MOD_DEFINED +#endif + +#if !defined(VUINT32x4_AVG_DEFINED) && defined(VUINT32x2_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 32, 4, 2) +# define VUINT32x4_AVG_DEFINED +#endif + +#if !defined(VUINT32x4_AND_DEFINED) && defined(VUINT32x2_AND_DEFINED) +VEC_DOUBLE_AND(u, 32, 4, 2) +# define VUINT32x4_AND_DEFINED +#endif + +#if !defined(VUINT32x4_OR_DEFINED) && defined(VUINT32x2_OR_DEFINED) +VEC_DOUBLE_OR(u, 32, 4, 2) +# define VUINT32x4_OR_DEFINED +#endif + +#if !defined(VUINT32x4_XOR_DEFINED) && defined(VUINT32x2_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 32, 4, 2) +# define VUINT32x4_XOR_DEFINED +#endif + +#if !defined(VUINT32x4_NOT_DEFINED) && defined(VUINT32x2_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 32, 4, 2) +# define VUINT32x4_NOT_DEFINED +#endif + +#if !defined(VUINT32x4_CMPLT_DEFINED) && defined(VUINT32x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 32, 4, 2) +# define VUINT32x4_CMPLT_DEFINED +#endif + +#if !defined(VUINT32x4_CMPEQ_DEFINED) && defined(VUINT32x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 32, 4, 2) +# define VUINT32x4_CMPEQ_DEFINED +#endif + +#if !defined(VUINT32x4_CMPGT_DEFINED) && defined(VUINT32x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 32, 4, 2) +# define VUINT32x4_CMPGT_DEFINED +#endif + +#if !defined(VUINT32x4_CMPLE_DEFINED) && defined(VUINT32x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 32, 4, 2) +# define VUINT32x4_CMPLE_DEFINED +#endif + +#if !defined(VUINT32x4_CMPGE_DEFINED) && defined(VUINT32x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 32, 4, 2) +# define VUINT32x4_CMPGE_DEFINED +#endif + +#if !defined(VUINT32x4_MIN_DEFINED) && defined(VUINT32x2_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 32, 4, 2) +# define VUINT32x4_MIN_DEFINED +#endif + +#if !defined(VUINT32x4_MAX_DEFINED) && defined(VUINT32x2_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 32, 4, 2) +# define VUINT32x4_MAX_DEFINED +#endif + +#if !defined(VUINT32x4_RSHIFT_DEFINED) && defined(VUINT32x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 32, 4, 2) +# define VUINT32x4_RSHIFT_DEFINED +#endif + +#if !defined(VUINT32x4_LRSHIFT_DEFINED) && defined(VUINT32x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 32, 4, 2) +# define VUINT32x4_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT32x4_LSHIFT_DEFINED) && defined(VUINT32x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 32, 4, 2) +# define VUINT32x4_LSHIFT_DEFINED +#endif + + + +/* vuint32x8 */ + +#if !defined(VINT32x8_SPLAT_DEFINED) && defined(VINT32x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 32, 8, 4) +# define VINT32x8_SPLAT_DEFINED +#endif + +#if !defined(VINT32x8_LOAD_ALIGNED_DEFINED) && defined(VINT32x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 8, 4) +# define VINT32x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x8_LOAD_DEFINED) && defined(VINT32x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 32, 8, 4) +# define VINT32x8_LOAD_DEFINED +#endif + +#if !defined(VINT32x8_STORE_ALIGNED_DEFINED) && defined(VINT32x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 8, 4) +# define VINT32x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x8_STORE_DEFINED) && defined(VINT32x4_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 32, 8, 4) +# define VINT32x8_STORE_DEFINED +#endif + +#if !defined(VINT32x8_ADD_DEFINED) && defined(VINT32x4_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 32, 8, 4) +# define VINT32x8_ADD_DEFINED +#endif + +#if !defined(VINT32x8_SUB_DEFINED) && defined(VINT32x4_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 32, 8, 4) +# define VINT32x8_SUB_DEFINED +#endif + +#if !defined(VINT32x8_MUL_DEFINED) && defined(VINT32x4_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 32, 8, 4) +# define VINT32x8_MUL_DEFINED +#endif + +#if !defined(VINT32x8_DIV_DEFINED) && defined(VINT32x4_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 32, 8, 4) +# define VINT32x8_DIV_DEFINED +#endif + +#if !defined(VINT32x8_MOD_DEFINED) && defined(VINT32x4_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 32, 8, 4) +# define VINT32x8_MOD_DEFINED +#endif + +#if !defined(VINT32x8_AVG_DEFINED) && defined(VINT32x4_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 32, 8, 4) +# define VINT32x8_AVG_DEFINED +#endif + +#if !defined(VINT32x8_AND_DEFINED) && defined(VINT32x4_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 32, 8, 4) +# define VINT32x8_AND_DEFINED +#endif + +#if !defined(VINT32x8_OR_DEFINED) && defined(VINT32x4_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 32, 8, 4) +# define VINT32x8_OR_DEFINED +#endif + +#if !defined(VINT32x8_XOR_DEFINED) && defined(VINT32x4_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 32, 8, 4) +# define VINT32x8_XOR_DEFINED +#endif + +#if !defined(VINT32x8_NOT_DEFINED) && defined(VINT32x4_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 32, 8, 4) +# define VINT32x8_NOT_DEFINED +#endif + +#if !defined(VINT32x8_CMPLT_DEFINED) && defined(VINT32x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 32, 8, 4) +# define VINT32x8_CMPLT_DEFINED +#endif + +#if !defined(VINT32x8_CMPEQ_DEFINED) && defined(VINT32x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 32, 8, 4) +# define VINT32x8_CMPEQ_DEFINED +#endif + +#if !defined(VINT32x8_CMPGT_DEFINED) && defined(VINT32x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 32, 8, 4) +# define VINT32x8_CMPGT_DEFINED +#endif + +#if !defined(VINT32x8_CMPLE_DEFINED) && defined(VINT32x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 32, 8, 4) +# define VINT32x8_CMPLE_DEFINED +#endif + +#if !defined(VINT32x8_CMPGE_DEFINED) && defined(VINT32x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 32, 8, 4) +# define VINT32x8_CMPGE_DEFINED +#endif + +#if !defined(VINT32x8_MIN_DEFINED) && defined(VINT32x4_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 32, 8, 4) +# define VINT32x8_MIN_DEFINED +#endif + +#if !defined(VINT32x8_MAX_DEFINED) && defined(VINT32x4_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 32, 8, 4) +# define VINT32x8_MAX_DEFINED +#endif + +#if !defined(VINT32x8_RSHIFT_DEFINED) && defined(VINT32x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 32, 8, 4) +# define VINT32x8_RSHIFT_DEFINED +#endif + +#if !defined(VINT32x8_LRSHIFT_DEFINED) && defined(VINT32x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 8, 4) +# define VINT32x8_LRSHIFT_DEFINED +#endif + +#if !defined(VINT32x8_LSHIFT_DEFINED) && defined(VINT32x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 32, 8, 4) +# define VINT32x8_LSHIFT_DEFINED +#endif + + + +/* vint32x8 */ + +#if !defined(VUINT32x8_SPLAT_DEFINED) && defined(VUINT32x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 32, 8, 4) +# define VUINT32x8_SPLAT_DEFINED +#endif + +#if !defined(VUINT32x8_LOAD_ALIGNED_DEFINED) && defined(VUINT32x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 32, 8, 4) +# define VUINT32x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x8_LOAD_DEFINED) && defined(VUINT32x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 32, 8, 4) +# define VUINT32x8_LOAD_DEFINED +#endif + +#if !defined(VUINT32x8_STORE_ALIGNED_DEFINED) && defined(VUINT32x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 32, 8, 4) +# define VUINT32x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x8_STORE_DEFINED) && defined(VUINT32x4_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 32, 8, 4) +# define VUINT32x8_STORE_DEFINED +#endif + +#if !defined(VUINT32x8_ADD_DEFINED) && defined(VUINT32x4_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 32, 8, 4) +# define VUINT32x8_ADD_DEFINED +#endif + +#if !defined(VUINT32x8_SUB_DEFINED) && defined(VUINT32x4_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 32, 8, 4) +# define VUINT32x8_SUB_DEFINED +#endif + +#if !defined(VUINT32x8_MUL_DEFINED) && defined(VUINT32x4_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 32, 8, 4) +# define VUINT32x8_MUL_DEFINED +#endif + +#if !defined(VUINT32x8_DIV_DEFINED) && defined(VUINT32x4_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 32, 8, 4) +# define VUINT32x8_DIV_DEFINED +#endif + +#if !defined(VUINT32x8_MOD_DEFINED) && defined(VUINT32x4_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 32, 8, 4) +# define VUINT32x8_MOD_DEFINED +#endif + +#if !defined(VUINT32x8_AVG_DEFINED) && defined(VUINT32x4_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 32, 8, 4) +# define VUINT32x8_AVG_DEFINED +#endif + +#if !defined(VUINT32x8_AND_DEFINED) && defined(VUINT32x4_AND_DEFINED) +VEC_DOUBLE_AND(u, 32, 8, 4) +# define VUINT32x8_AND_DEFINED +#endif + +#if !defined(VUINT32x8_OR_DEFINED) && defined(VUINT32x4_OR_DEFINED) +VEC_DOUBLE_OR(u, 32, 8, 4) +# define VUINT32x8_OR_DEFINED +#endif + +#if !defined(VUINT32x8_XOR_DEFINED) && defined(VUINT32x4_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 32, 8, 4) +# define VUINT32x8_XOR_DEFINED +#endif + +#if !defined(VUINT32x8_NOT_DEFINED) && defined(VUINT32x4_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 32, 8, 4) +# define VUINT32x8_NOT_DEFINED +#endif + +#if !defined(VUINT32x8_CMPLT_DEFINED) && defined(VUINT32x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 32, 8, 4) +# define VUINT32x8_CMPLT_DEFINED +#endif + +#if !defined(VUINT32x8_CMPEQ_DEFINED) && defined(VUINT32x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 32, 8, 4) +# define VUINT32x8_CMPEQ_DEFINED +#endif + +#if !defined(VUINT32x8_CMPGT_DEFINED) && defined(VUINT32x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 32, 8, 4) +# define VUINT32x8_CMPGT_DEFINED +#endif + +#if !defined(VUINT32x8_CMPLE_DEFINED) && defined(VUINT32x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 32, 8, 4) +# define VUINT32x8_CMPLE_DEFINED +#endif + +#if !defined(VUINT32x8_CMPGE_DEFINED) && defined(VUINT32x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 32, 8, 4) +# define VUINT32x8_CMPGE_DEFINED +#endif + +#if !defined(VUINT32x8_MIN_DEFINED) && defined(VUINT32x4_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 32, 8, 4) +# define VUINT32x8_MIN_DEFINED +#endif + +#if !defined(VUINT32x8_MAX_DEFINED) && defined(VUINT32x4_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 32, 8, 4) +# define VUINT32x8_MAX_DEFINED +#endif + +#if !defined(VUINT32x8_RSHIFT_DEFINED) && defined(VUINT32x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 32, 8, 4) +# define VUINT32x8_RSHIFT_DEFINED +#endif + +#if !defined(VUINT32x8_LRSHIFT_DEFINED) && defined(VUINT32x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 32, 8, 4) +# define VUINT32x8_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT32x8_LSHIFT_DEFINED) && defined(VUINT32x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 32, 8, 4) +# define VUINT32x8_LSHIFT_DEFINED +#endif + + + +/* vuint32x16 */ + +#if !defined(VINT32x16_SPLAT_DEFINED) && defined(VINT32x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 32, 16, 8) +# define VINT32x16_SPLAT_DEFINED +#endif + +#if !defined(VINT32x16_LOAD_ALIGNED_DEFINED) && defined(VINT32x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 16, 8) +# define VINT32x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x16_LOAD_DEFINED) && defined(VINT32x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 32, 16, 8) +# define VINT32x16_LOAD_DEFINED +#endif + +#if !defined(VINT32x16_STORE_ALIGNED_DEFINED) && defined(VINT32x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 16, 8) +# define VINT32x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT32x16_STORE_DEFINED) && defined(VINT32x8_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 32, 16, 8) +# define VINT32x16_STORE_DEFINED +#endif + +#if !defined(VINT32x16_ADD_DEFINED) && defined(VINT32x8_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 32, 16, 8) +# define VINT32x16_ADD_DEFINED +#endif + +#if !defined(VINT32x16_SUB_DEFINED) && defined(VINT32x8_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 32, 16, 8) +# define VINT32x16_SUB_DEFINED +#endif + +#if !defined(VINT32x16_MUL_DEFINED) && defined(VINT32x8_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 32, 16, 8) +# define VINT32x16_MUL_DEFINED +#endif + +#if !defined(VINT32x16_DIV_DEFINED) && defined(VINT32x8_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 32, 16, 8) +# define VINT32x16_DIV_DEFINED +#endif + +#if !defined(VINT32x16_MOD_DEFINED) && defined(VINT32x8_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 32, 16, 8) +# define VINT32x16_MOD_DEFINED +#endif + +#if !defined(VINT32x16_AVG_DEFINED) && defined(VINT32x8_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 32, 16, 8) +# define VINT32x16_AVG_DEFINED +#endif + +#if !defined(VINT32x16_AND_DEFINED) && defined(VINT32x8_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 32, 16, 8) +# define VINT32x16_AND_DEFINED +#endif + +#if !defined(VINT32x16_OR_DEFINED) && defined(VINT32x8_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 32, 16, 8) +# define VINT32x16_OR_DEFINED +#endif + +#if !defined(VINT32x16_XOR_DEFINED) && defined(VINT32x8_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 32, 16, 8) +# define VINT32x16_XOR_DEFINED +#endif + +#if !defined(VINT32x16_NOT_DEFINED) && defined(VINT32x8_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 32, 16, 8) +# define VINT32x16_NOT_DEFINED +#endif + +#if !defined(VINT32x16_CMPLT_DEFINED) && defined(VINT32x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 32, 16, 8) +# define VINT32x16_CMPLT_DEFINED +#endif + +#if !defined(VINT32x16_CMPEQ_DEFINED) && defined(VINT32x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 32, 16, 8) +# define VINT32x16_CMPEQ_DEFINED +#endif + +#if !defined(VINT32x16_CMPGT_DEFINED) && defined(VINT32x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 32, 16, 8) +# define VINT32x16_CMPGT_DEFINED +#endif + +#if !defined(VINT32x16_CMPLE_DEFINED) && defined(VINT32x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 32, 16, 8) +# define VINT32x16_CMPLE_DEFINED +#endif + +#if !defined(VINT32x16_CMPGE_DEFINED) && defined(VINT32x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 32, 16, 8) +# define VINT32x16_CMPGE_DEFINED +#endif + +#if !defined(VINT32x16_MIN_DEFINED) && defined(VINT32x8_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 32, 16, 8) +# define VINT32x16_MIN_DEFINED +#endif + +#if !defined(VINT32x16_MAX_DEFINED) && defined(VINT32x8_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 32, 16, 8) +# define VINT32x16_MAX_DEFINED +#endif + +#if !defined(VINT32x16_RSHIFT_DEFINED) && defined(VINT32x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 32, 16, 8) +# define VINT32x16_RSHIFT_DEFINED +#endif + +#if !defined(VINT32x16_LRSHIFT_DEFINED) && defined(VINT32x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 16, 8) +# define VINT32x16_LRSHIFT_DEFINED +#endif + +#if !defined(VINT32x16_LSHIFT_DEFINED) && defined(VINT32x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 32, 16, 8) +# define VINT32x16_LSHIFT_DEFINED +#endif + + + +/* vint32x16 */ + +#if !defined(VUINT32x16_SPLAT_DEFINED) && defined(VUINT32x8_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 32, 16, 8) +# define VUINT32x16_SPLAT_DEFINED +#endif + +#if !defined(VUINT32x16_LOAD_ALIGNED_DEFINED) && defined(VUINT32x8_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 32, 16, 8) +# define VUINT32x16_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x16_LOAD_DEFINED) && defined(VUINT32x8_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 32, 16, 8) +# define VUINT32x16_LOAD_DEFINED +#endif + +#if !defined(VUINT32x16_STORE_ALIGNED_DEFINED) && defined(VUINT32x8_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 32, 16, 8) +# define VUINT32x16_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT32x16_STORE_DEFINED) && defined(VUINT32x8_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 32, 16, 8) +# define VUINT32x16_STORE_DEFINED +#endif + +#if !defined(VUINT32x16_ADD_DEFINED) && defined(VUINT32x8_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 32, 16, 8) +# define VUINT32x16_ADD_DEFINED +#endif + +#if !defined(VUINT32x16_SUB_DEFINED) && defined(VUINT32x8_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 32, 16, 8) +# define VUINT32x16_SUB_DEFINED +#endif + +#if !defined(VUINT32x16_MUL_DEFINED) && defined(VUINT32x8_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 32, 16, 8) +# define VUINT32x16_MUL_DEFINED +#endif + +#if !defined(VUINT32x16_DIV_DEFINED) && defined(VUINT32x8_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 32, 16, 8) +# define VUINT32x16_DIV_DEFINED +#endif + +#if !defined(VUINT32x16_MOD_DEFINED) && defined(VUINT32x8_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 32, 16, 8) +# define VUINT32x16_MOD_DEFINED +#endif + +#if !defined(VUINT32x16_AVG_DEFINED) && defined(VUINT32x8_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 32, 16, 8) +# define VUINT32x16_AVG_DEFINED +#endif + +#if !defined(VUINT32x16_AND_DEFINED) && defined(VUINT32x8_AND_DEFINED) +VEC_DOUBLE_AND(u, 32, 16, 8) +# define VUINT32x16_AND_DEFINED +#endif + +#if !defined(VUINT32x16_OR_DEFINED) && defined(VUINT32x8_OR_DEFINED) +VEC_DOUBLE_OR(u, 32, 16, 8) +# define VUINT32x16_OR_DEFINED +#endif + +#if !defined(VUINT32x16_XOR_DEFINED) && defined(VUINT32x8_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 32, 16, 8) +# define VUINT32x16_XOR_DEFINED +#endif + +#if !defined(VUINT32x16_NOT_DEFINED) && defined(VUINT32x8_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 32, 16, 8) +# define VUINT32x16_NOT_DEFINED +#endif + +#if !defined(VUINT32x16_CMPLT_DEFINED) && defined(VUINT32x8_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 32, 16, 8) +# define VUINT32x16_CMPLT_DEFINED +#endif + +#if !defined(VUINT32x16_CMPEQ_DEFINED) && defined(VUINT32x8_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 32, 16, 8) +# define VUINT32x16_CMPEQ_DEFINED +#endif + +#if !defined(VUINT32x16_CMPGT_DEFINED) && defined(VUINT32x8_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 32, 16, 8) +# define VUINT32x16_CMPGT_DEFINED +#endif + +#if !defined(VUINT32x16_CMPLE_DEFINED) && defined(VUINT32x8_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 32, 16, 8) +# define VUINT32x16_CMPLE_DEFINED +#endif + +#if !defined(VUINT32x16_CMPGE_DEFINED) && defined(VUINT32x8_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 32, 16, 8) +# define VUINT32x16_CMPGE_DEFINED +#endif + +#if !defined(VUINT32x16_MIN_DEFINED) && defined(VUINT32x8_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 32, 16, 8) +# define VUINT32x16_MIN_DEFINED +#endif + +#if !defined(VUINT32x16_MAX_DEFINED) && defined(VUINT32x8_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 32, 16, 8) +# define VUINT32x16_MAX_DEFINED +#endif + +#if !defined(VUINT32x16_RSHIFT_DEFINED) && defined(VUINT32x8_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 32, 16, 8) +# define VUINT32x16_RSHIFT_DEFINED +#endif + +#if !defined(VUINT32x16_LRSHIFT_DEFINED) && defined(VUINT32x8_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 32, 16, 8) +# define VUINT32x16_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT32x16_LSHIFT_DEFINED) && defined(VUINT32x8_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 32, 16, 8) +# define VUINT32x16_LSHIFT_DEFINED +#endif + + + +/* vuint64x4 */ + +#if !defined(VINT64x4_SPLAT_DEFINED) && defined(VINT64x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 64, 4, 2) +# define VINT64x4_SPLAT_DEFINED +#endif + +#if !defined(VINT64x4_LOAD_ALIGNED_DEFINED) && defined(VINT64x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 64, 4, 2) +# define VINT64x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT64x4_LOAD_DEFINED) && defined(VINT64x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 64, 4, 2) +# define VINT64x4_LOAD_DEFINED +#endif + +#if !defined(VINT64x4_STORE_ALIGNED_DEFINED) && defined(VINT64x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 64, 4, 2) +# define VINT64x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT64x4_STORE_DEFINED) && defined(VINT64x2_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 64, 4, 2) +# define VINT64x4_STORE_DEFINED +#endif + +#if !defined(VINT64x4_ADD_DEFINED) && defined(VINT64x2_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 64, 4, 2) +# define VINT64x4_ADD_DEFINED +#endif + +#if !defined(VINT64x4_SUB_DEFINED) && defined(VINT64x2_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 64, 4, 2) +# define VINT64x4_SUB_DEFINED +#endif + +#if !defined(VINT64x4_MUL_DEFINED) && defined(VINT64x2_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 64, 4, 2) +# define VINT64x4_MUL_DEFINED +#endif + +#if !defined(VINT64x4_DIV_DEFINED) && defined(VINT64x2_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 64, 4, 2) +# define VINT64x4_DIV_DEFINED +#endif + +#if !defined(VINT64x4_MOD_DEFINED) && defined(VINT64x2_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 64, 4, 2) +# define VINT64x4_MOD_DEFINED +#endif + +#if !defined(VINT64x4_AVG_DEFINED) && defined(VINT64x2_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 64, 4, 2) +# define VINT64x4_AVG_DEFINED +#endif + +#if !defined(VINT64x4_AND_DEFINED) && defined(VINT64x2_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 64, 4, 2) +# define VINT64x4_AND_DEFINED +#endif + +#if !defined(VINT64x4_OR_DEFINED) && defined(VINT64x2_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 64, 4, 2) +# define VINT64x4_OR_DEFINED +#endif + +#if !defined(VINT64x4_XOR_DEFINED) && defined(VINT64x2_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 64, 4, 2) +# define VINT64x4_XOR_DEFINED +#endif + +#if !defined(VINT64x4_NOT_DEFINED) && defined(VINT64x2_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 64, 4, 2) +# define VINT64x4_NOT_DEFINED +#endif + +#if !defined(VINT64x4_CMPLT_DEFINED) && defined(VINT64x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 64, 4, 2) +# define VINT64x4_CMPLT_DEFINED +#endif + +#if !defined(VINT64x4_CMPEQ_DEFINED) && defined(VINT64x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 64, 4, 2) +# define VINT64x4_CMPEQ_DEFINED +#endif + +#if !defined(VINT64x4_CMPGT_DEFINED) && defined(VINT64x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 64, 4, 2) +# define VINT64x4_CMPGT_DEFINED +#endif + +#if !defined(VINT64x4_CMPLE_DEFINED) && defined(VINT64x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 64, 4, 2) +# define VINT64x4_CMPLE_DEFINED +#endif + +#if !defined(VINT64x4_CMPGE_DEFINED) && defined(VINT64x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 64, 4, 2) +# define VINT64x4_CMPGE_DEFINED +#endif + +#if !defined(VINT64x4_MIN_DEFINED) && defined(VINT64x2_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 64, 4, 2) +# define VINT64x4_MIN_DEFINED +#endif + +#if !defined(VINT64x4_MAX_DEFINED) && defined(VINT64x2_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 64, 4, 2) +# define VINT64x4_MAX_DEFINED +#endif + +#if !defined(VINT64x4_RSHIFT_DEFINED) && defined(VINT64x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 64, 4, 2) +# define VINT64x4_RSHIFT_DEFINED +#endif + +#if !defined(VINT64x4_LRSHIFT_DEFINED) && defined(VINT64x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 64, 4, 2) +# define VINT64x4_LRSHIFT_DEFINED +#endif + +#if !defined(VINT64x4_LSHIFT_DEFINED) && defined(VINT64x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 64, 4, 2) +# define VINT64x4_LSHIFT_DEFINED +#endif + + + +/* vint64x4 */ + +#if !defined(VUINT64x4_SPLAT_DEFINED) && defined(VUINT64x2_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 64, 4, 2) +# define VUINT64x4_SPLAT_DEFINED +#endif + +#if !defined(VUINT64x4_LOAD_ALIGNED_DEFINED) && defined(VUINT64x2_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 64, 4, 2) +# define VUINT64x4_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT64x4_LOAD_DEFINED) && defined(VUINT64x2_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 64, 4, 2) +# define VUINT64x4_LOAD_DEFINED +#endif + +#if !defined(VUINT64x4_STORE_ALIGNED_DEFINED) && defined(VUINT64x2_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 64, 4, 2) +# define VUINT64x4_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT64x4_STORE_DEFINED) && defined(VUINT64x2_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 64, 4, 2) +# define VUINT64x4_STORE_DEFINED +#endif + +#if !defined(VUINT64x4_ADD_DEFINED) && defined(VUINT64x2_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 64, 4, 2) +# define VUINT64x4_ADD_DEFINED +#endif + +#if !defined(VUINT64x4_SUB_DEFINED) && defined(VUINT64x2_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 64, 4, 2) +# define VUINT64x4_SUB_DEFINED +#endif + +#if !defined(VUINT64x4_MUL_DEFINED) && defined(VUINT64x2_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 64, 4, 2) +# define VUINT64x4_MUL_DEFINED +#endif + +#if !defined(VUINT64x4_DIV_DEFINED) && defined(VUINT64x2_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 64, 4, 2) +# define VUINT64x4_DIV_DEFINED +#endif + +#if !defined(VUINT64x4_MOD_DEFINED) && defined(VUINT64x2_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 64, 4, 2) +# define VUINT64x4_MOD_DEFINED +#endif + +#if !defined(VUINT64x4_AVG_DEFINED) && defined(VUINT64x2_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 64, 4, 2) +# define VUINT64x4_AVG_DEFINED +#endif + +#if !defined(VUINT64x4_AND_DEFINED) && defined(VUINT64x2_AND_DEFINED) +VEC_DOUBLE_AND(u, 64, 4, 2) +# define VUINT64x4_AND_DEFINED +#endif + +#if !defined(VUINT64x4_OR_DEFINED) && defined(VUINT64x2_OR_DEFINED) +VEC_DOUBLE_OR(u, 64, 4, 2) +# define VUINT64x4_OR_DEFINED +#endif + +#if !defined(VUINT64x4_XOR_DEFINED) && defined(VUINT64x2_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 64, 4, 2) +# define VUINT64x4_XOR_DEFINED +#endif + +#if !defined(VUINT64x4_NOT_DEFINED) && defined(VUINT64x2_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 64, 4, 2) +# define VUINT64x4_NOT_DEFINED +#endif + +#if !defined(VUINT64x4_CMPLT_DEFINED) && defined(VUINT64x2_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 64, 4, 2) +# define VUINT64x4_CMPLT_DEFINED +#endif + +#if !defined(VUINT64x4_CMPEQ_DEFINED) && defined(VUINT64x2_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 64, 4, 2) +# define VUINT64x4_CMPEQ_DEFINED +#endif + +#if !defined(VUINT64x4_CMPGT_DEFINED) && defined(VUINT64x2_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 64, 4, 2) +# define VUINT64x4_CMPGT_DEFINED +#endif + +#if !defined(VUINT64x4_CMPLE_DEFINED) && defined(VUINT64x2_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 64, 4, 2) +# define VUINT64x4_CMPLE_DEFINED +#endif + +#if !defined(VUINT64x4_CMPGE_DEFINED) && defined(VUINT64x2_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 64, 4, 2) +# define VUINT64x4_CMPGE_DEFINED +#endif + +#if !defined(VUINT64x4_MIN_DEFINED) && defined(VUINT64x2_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 64, 4, 2) +# define VUINT64x4_MIN_DEFINED +#endif + +#if !defined(VUINT64x4_MAX_DEFINED) && defined(VUINT64x2_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 64, 4, 2) +# define VUINT64x4_MAX_DEFINED +#endif + +#if !defined(VUINT64x4_RSHIFT_DEFINED) && defined(VUINT64x2_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 64, 4, 2) +# define VUINT64x4_RSHIFT_DEFINED +#endif + +#if !defined(VUINT64x4_LRSHIFT_DEFINED) && defined(VUINT64x2_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 64, 4, 2) +# define VUINT64x4_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT64x4_LSHIFT_DEFINED) && defined(VUINT64x2_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 64, 4, 2) +# define VUINT64x4_LSHIFT_DEFINED +#endif + + + +/* vuint64x8 */ + +#if !defined(VINT64x8_SPLAT_DEFINED) && defined(VINT64x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(/* nothing */, 64, 8, 4) +# define VINT64x8_SPLAT_DEFINED +#endif + +#if !defined(VINT64x8_LOAD_ALIGNED_DEFINED) && defined(VINT64x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 64, 8, 4) +# define VINT64x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VINT64x8_LOAD_DEFINED) && defined(VINT64x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(/* nothing */, 64, 8, 4) +# define VINT64x8_LOAD_DEFINED +#endif + +#if !defined(VINT64x8_STORE_ALIGNED_DEFINED) && defined(VINT64x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 64, 8, 4) +# define VINT64x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VINT64x8_STORE_DEFINED) && defined(VINT64x4_STORE_DEFINED) +VEC_DOUBLE_STORE(/* nothing */, 64, 8, 4) +# define VINT64x8_STORE_DEFINED +#endif + +#if !defined(VINT64x8_ADD_DEFINED) && defined(VINT64x4_ADD_DEFINED) +VEC_DOUBLE_ADD(/* nothing */, 64, 8, 4) +# define VINT64x8_ADD_DEFINED +#endif + +#if !defined(VINT64x8_SUB_DEFINED) && defined(VINT64x4_SUB_DEFINED) +VEC_DOUBLE_SUB(/* nothing */, 64, 8, 4) +# define VINT64x8_SUB_DEFINED +#endif + +#if !defined(VINT64x8_MUL_DEFINED) && defined(VINT64x4_MUL_DEFINED) +VEC_DOUBLE_MUL(/* nothing */, 64, 8, 4) +# define VINT64x8_MUL_DEFINED +#endif + +#if !defined(VINT64x8_DIV_DEFINED) && defined(VINT64x4_DIV_DEFINED) +VEC_DOUBLE_DIV(/* nothing */, 64, 8, 4) +# define VINT64x8_DIV_DEFINED +#endif + +#if !defined(VINT64x8_MOD_DEFINED) && defined(VINT64x4_MOD_DEFINED) +VEC_DOUBLE_MOD(/* nothing */, 64, 8, 4) +# define VINT64x8_MOD_DEFINED +#endif + +#if !defined(VINT64x8_AVG_DEFINED) && defined(VINT64x4_AVG_DEFINED) +VEC_DOUBLE_AVG(/* nothing */, 64, 8, 4) +# define VINT64x8_AVG_DEFINED +#endif + +#if !defined(VINT64x8_AND_DEFINED) && defined(VINT64x4_AND_DEFINED) +VEC_DOUBLE_AND(/* nothing */, 64, 8, 4) +# define VINT64x8_AND_DEFINED +#endif + +#if !defined(VINT64x8_OR_DEFINED) && defined(VINT64x4_OR_DEFINED) +VEC_DOUBLE_OR(/* nothing */, 64, 8, 4) +# define VINT64x8_OR_DEFINED +#endif + +#if !defined(VINT64x8_XOR_DEFINED) && defined(VINT64x4_XOR_DEFINED) +VEC_DOUBLE_XOR(/* nothing */, 64, 8, 4) +# define VINT64x8_XOR_DEFINED +#endif + +#if !defined(VINT64x8_NOT_DEFINED) && defined(VINT64x4_NOT_DEFINED) +VEC_DOUBLE_NOT(/* nothing */, 64, 8, 4) +# define VINT64x8_NOT_DEFINED +#endif + +#if !defined(VINT64x8_CMPLT_DEFINED) && defined(VINT64x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(/* nothing */, 64, 8, 4) +# define VINT64x8_CMPLT_DEFINED +#endif + +#if !defined(VINT64x8_CMPEQ_DEFINED) && defined(VINT64x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(/* nothing */, 64, 8, 4) +# define VINT64x8_CMPEQ_DEFINED +#endif + +#if !defined(VINT64x8_CMPGT_DEFINED) && defined(VINT64x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(/* nothing */, 64, 8, 4) +# define VINT64x8_CMPGT_DEFINED +#endif + +#if !defined(VINT64x8_CMPLE_DEFINED) && defined(VINT64x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(/* nothing */, 64, 8, 4) +# define VINT64x8_CMPLE_DEFINED +#endif + +#if !defined(VINT64x8_CMPGE_DEFINED) && defined(VINT64x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(/* nothing */, 64, 8, 4) +# define VINT64x8_CMPGE_DEFINED +#endif + +#if !defined(VINT64x8_MIN_DEFINED) && defined(VINT64x4_MIN_DEFINED) +VEC_DOUBLE_MIN(/* nothing */, 64, 8, 4) +# define VINT64x8_MIN_DEFINED +#endif + +#if !defined(VINT64x8_MAX_DEFINED) && defined(VINT64x4_MAX_DEFINED) +VEC_DOUBLE_MAX(/* nothing */, 64, 8, 4) +# define VINT64x8_MAX_DEFINED +#endif + +#if !defined(VINT64x8_RSHIFT_DEFINED) && defined(VINT64x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(/* nothing */, 64, 8, 4) +# define VINT64x8_RSHIFT_DEFINED +#endif + +#if !defined(VINT64x8_LRSHIFT_DEFINED) && defined(VINT64x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(/* nothing */, 64, 8, 4) +# define VINT64x8_LRSHIFT_DEFINED +#endif + +#if !defined(VINT64x8_LSHIFT_DEFINED) && defined(VINT64x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(/* nothing */, 64, 8, 4) +# define VINT64x8_LSHIFT_DEFINED +#endif + + + +/* vint64x8 */ + +#if !defined(VUINT64x8_SPLAT_DEFINED) && defined(VUINT64x4_SPLAT_DEFINED) +VEC_DOUBLE_SPLAT(u, 64, 8, 4) +# define VUINT64x8_SPLAT_DEFINED +#endif + +#if !defined(VUINT64x8_LOAD_ALIGNED_DEFINED) && defined(VUINT64x4_LOAD_ALIGNED_DEFINED) +VEC_DOUBLE_LOAD_ALIGNED(u, 64, 8, 4) +# define VUINT64x8_LOAD_ALIGNED_DEFINED +#endif + +#if !defined(VUINT64x8_LOAD_DEFINED) && defined(VUINT64x4_LOAD_DEFINED) +VEC_DOUBLE_LOAD(u, 64, 8, 4) +# define VUINT64x8_LOAD_DEFINED +#endif + +#if !defined(VUINT64x8_STORE_ALIGNED_DEFINED) && defined(VUINT64x4_STORE_ALIGNED_DEFINED) +VEC_DOUBLE_STORE_ALIGNED(u, 64, 8, 4) +# define VUINT64x8_STORE_ALIGNED_DEFINED +#endif + +#if !defined(VUINT64x8_STORE_DEFINED) && defined(VUINT64x4_STORE_DEFINED) +VEC_DOUBLE_STORE(u, 64, 8, 4) +# define VUINT64x8_STORE_DEFINED +#endif + +#if !defined(VUINT64x8_ADD_DEFINED) && defined(VUINT64x4_ADD_DEFINED) +VEC_DOUBLE_ADD(u, 64, 8, 4) +# define VUINT64x8_ADD_DEFINED +#endif + +#if !defined(VUINT64x8_SUB_DEFINED) && defined(VUINT64x4_SUB_DEFINED) +VEC_DOUBLE_SUB(u, 64, 8, 4) +# define VUINT64x8_SUB_DEFINED +#endif + +#if !defined(VUINT64x8_MUL_DEFINED) && defined(VUINT64x4_MUL_DEFINED) +VEC_DOUBLE_MUL(u, 64, 8, 4) +# define VUINT64x8_MUL_DEFINED +#endif + +#if !defined(VUINT64x8_DIV_DEFINED) && defined(VUINT64x4_DIV_DEFINED) +VEC_DOUBLE_DIV(u, 64, 8, 4) +# define VUINT64x8_DIV_DEFINED +#endif + +#if !defined(VUINT64x8_MOD_DEFINED) && defined(VUINT64x4_MOD_DEFINED) +VEC_DOUBLE_MOD(u, 64, 8, 4) +# define VUINT64x8_MOD_DEFINED +#endif + +#if !defined(VUINT64x8_AVG_DEFINED) && defined(VUINT64x4_AVG_DEFINED) +VEC_DOUBLE_AVG(u, 64, 8, 4) +# define VUINT64x8_AVG_DEFINED +#endif + +#if !defined(VUINT64x8_AND_DEFINED) && defined(VUINT64x4_AND_DEFINED) +VEC_DOUBLE_AND(u, 64, 8, 4) +# define VUINT64x8_AND_DEFINED +#endif + +#if !defined(VUINT64x8_OR_DEFINED) && defined(VUINT64x4_OR_DEFINED) +VEC_DOUBLE_OR(u, 64, 8, 4) +# define VUINT64x8_OR_DEFINED +#endif + +#if !defined(VUINT64x8_XOR_DEFINED) && defined(VUINT64x4_XOR_DEFINED) +VEC_DOUBLE_XOR(u, 64, 8, 4) +# define VUINT64x8_XOR_DEFINED +#endif + +#if !defined(VUINT64x8_NOT_DEFINED) && defined(VUINT64x4_NOT_DEFINED) +VEC_DOUBLE_NOT(u, 64, 8, 4) +# define VUINT64x8_NOT_DEFINED +#endif + +#if !defined(VUINT64x8_CMPLT_DEFINED) && defined(VUINT64x4_CMPLT_DEFINED) +VEC_DOUBLE_CMPLT(u, 64, 8, 4) +# define VUINT64x8_CMPLT_DEFINED +#endif + +#if !defined(VUINT64x8_CMPEQ_DEFINED) && defined(VUINT64x4_CMPEQ_DEFINED) +VEC_DOUBLE_CMPEQ(u, 64, 8, 4) +# define VUINT64x8_CMPEQ_DEFINED +#endif + +#if !defined(VUINT64x8_CMPGT_DEFINED) && defined(VUINT64x4_CMPGT_DEFINED) +VEC_DOUBLE_CMPGT(u, 64, 8, 4) +# define VUINT64x8_CMPGT_DEFINED +#endif + +#if !defined(VUINT64x8_CMPLE_DEFINED) && defined(VUINT64x4_CMPLE_DEFINED) +VEC_DOUBLE_CMPLE(u, 64, 8, 4) +# define VUINT64x8_CMPLE_DEFINED +#endif + +#if !defined(VUINT64x8_CMPGE_DEFINED) && defined(VUINT64x4_CMPGE_DEFINED) +VEC_DOUBLE_CMPGE(u, 64, 8, 4) +# define VUINT64x8_CMPGE_DEFINED +#endif + +#if !defined(VUINT64x8_MIN_DEFINED) && defined(VUINT64x4_MIN_DEFINED) +VEC_DOUBLE_MIN(u, 64, 8, 4) +# define VUINT64x8_MIN_DEFINED +#endif + +#if !defined(VUINT64x8_MAX_DEFINED) && defined(VUINT64x4_MAX_DEFINED) +VEC_DOUBLE_MAX(u, 64, 8, 4) +# define VUINT64x8_MAX_DEFINED +#endif + +#if !defined(VUINT64x8_RSHIFT_DEFINED) && defined(VUINT64x4_RSHIFT_DEFINED) +VEC_DOUBLE_RSHIFT(u, 64, 8, 4) +# define VUINT64x8_RSHIFT_DEFINED +#endif + +#if !defined(VUINT64x8_LRSHIFT_DEFINED) && defined(VUINT64x4_LRSHIFT_DEFINED) +VEC_DOUBLE_LRSHIFT(u, 64, 8, 4) +# define VUINT64x8_LRSHIFT_DEFINED +#endif + +#if !defined(VUINT64x8_LSHIFT_DEFINED) && defined(VUINT64x4_LSHIFT_DEFINED) +VEC_DOUBLE_LSHIFT(u, 64, 8, 4) +# define VUINT64x8_LSHIFT_DEFINED +#endif + +
--- a/include/vec/impl/gcc.h Sun Apr 27 02:49:53 2025 -0400 +++ b/include/vec/impl/gcc.h Mon Apr 28 16:31:59 2025 -0400 @@ -122,6 +122,7 @@ } # define VINT8x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_CMPLT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_cmplt(vint8x2 vec1, vint8x2 vec2) { @@ -130,6 +131,8 @@ } # define VINT8x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_cmpeq(vint8x2 vec1, vint8x2 vec2) { @@ -138,6 +141,8 @@ } # define VINT8x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_CMPGT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_cmpgt(vint8x2 vec1, vint8x2 vec2) { @@ -146,6 +151,8 @@ } # define VINT8x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_CMPLE_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_cmple(vint8x2 vec1, vint8x2 vec2) { @@ -154,6 +161,8 @@ } # define VINT8x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_CMPGE_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_cmpge(vint8x2 vec1, vint8x2 vec2) { @@ -162,6 +171,8 @@ } # define VINT8x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_MIN_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_min(vint8x2 vec1, vint8x2 vec2) { @@ -172,6 +183,8 @@ } # define VINT8x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_MAX_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_max(vint8x2 vec1, vint8x2 vec2) { @@ -182,6 +195,8 @@ } # define VINT8x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_AVG_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_avg(vint8x2 vec1, vint8x2 vec2) { @@ -196,6 +211,8 @@ } # define VINT8x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_lshift(vint8x2 vec1, vuint8x2 vec2) { @@ -204,6 +221,8 @@ } # define VINT8x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_rshift(vint8x2 vec1, vuint8x2 vec2) { @@ -212,6 +231,8 @@ } # define VINT8x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_lrshift(vint8x2 vec1, vuint8x2 vec2) { @@ -220,6 +241,7 @@ } # define VINT8x2_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x2_NOT_DEFINED VEC_FUNC_IMPL vint8x2 vint8x2_not(vint8x2 vec) { @@ -321,6 +343,7 @@ } # define VUINT8x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_cmplt(vuint8x2 vec1, vuint8x2 vec2) { @@ -329,6 +352,8 @@ } # define VUINT8x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpeq(vuint8x2 vec1, vuint8x2 vec2) { @@ -337,6 +362,8 @@ } # define VUINT8x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpgt(vuint8x2 vec1, vuint8x2 vec2) { @@ -345,6 +372,8 @@ } # define VUINT8x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_cmple(vuint8x2 vec1, vuint8x2 vec2) { @@ -353,6 +382,8 @@ } # define VUINT8x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpge(vuint8x2 vec1, vuint8x2 vec2) { @@ -361,6 +392,8 @@ } # define VUINT8x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_MIN_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_min(vuint8x2 vec1, vuint8x2 vec2) { @@ -371,6 +404,8 @@ } # define VUINT8x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_MAX_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_max(vuint8x2 vec1, vuint8x2 vec2) { @@ -381,14 +416,19 @@ } # define VUINT8x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_AVG_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_avg(vuint8x2 vec1, vuint8x2 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x2 ones = vint8x2_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_lshift(vuint8x2 vec1, vuint8x2 vec2) { @@ -397,6 +437,8 @@ } # define VUINT8x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_rshift(vuint8x2 vec1, vuint8x2 vec2) { @@ -405,6 +447,8 @@ } # define VUINT8x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_lrshift(vuint8x2 vec1, vuint8x2 vec2) { @@ -413,6 +457,7 @@ } # define VUINT8x2_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x2_NOT_DEFINED VEC_FUNC_IMPL vuint8x2 vuint8x2_not(vuint8x2 vec) { @@ -514,6 +559,7 @@ } # define VINT8x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_CMPLT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_cmplt(vint8x4 vec1, vint8x4 vec2) { @@ -522,6 +568,8 @@ } # define VINT8x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_cmpeq(vint8x4 vec1, vint8x4 vec2) { @@ -530,6 +578,8 @@ } # define VINT8x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_CMPGT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_cmpgt(vint8x4 vec1, vint8x4 vec2) { @@ -538,6 +588,8 @@ } # define VINT8x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_CMPLE_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_cmple(vint8x4 vec1, vint8x4 vec2) { @@ -546,6 +598,8 @@ } # define VINT8x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_CMPGE_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_cmpge(vint8x4 vec1, vint8x4 vec2) { @@ -554,6 +608,8 @@ } # define VINT8x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_MIN_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_min(vint8x4 vec1, vint8x4 vec2) { @@ -564,6 +620,8 @@ } # define VINT8x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_MAX_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_max(vint8x4 vec1, vint8x4 vec2) { @@ -574,6 +632,8 @@ } # define VINT8x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_AVG_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_avg(vint8x4 vec1, vint8x4 vec2) { @@ -588,6 +648,8 @@ } # define VINT8x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_lshift(vint8x4 vec1, vuint8x4 vec2) { @@ -596,6 +658,8 @@ } # define VINT8x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_rshift(vint8x4 vec1, vuint8x4 vec2) { @@ -604,6 +668,8 @@ } # define VINT8x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_lrshift(vint8x4 vec1, vuint8x4 vec2) { @@ -612,6 +678,7 @@ } # define VINT8x4_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x4_NOT_DEFINED VEC_FUNC_IMPL vint8x4 vint8x4_not(vint8x4 vec) { @@ -713,6 +780,7 @@ } # define VUINT8x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_cmplt(vuint8x4 vec1, vuint8x4 vec2) { @@ -721,6 +789,8 @@ } # define VUINT8x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpeq(vuint8x4 vec1, vuint8x4 vec2) { @@ -729,6 +799,8 @@ } # define VUINT8x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpgt(vuint8x4 vec1, vuint8x4 vec2) { @@ -737,6 +809,8 @@ } # define VUINT8x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_cmple(vuint8x4 vec1, vuint8x4 vec2) { @@ -745,6 +819,8 @@ } # define VUINT8x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpge(vuint8x4 vec1, vuint8x4 vec2) { @@ -753,6 +829,8 @@ } # define VUINT8x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_MIN_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_min(vuint8x4 vec1, vuint8x4 vec2) { @@ -763,6 +841,8 @@ } # define VUINT8x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_MAX_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_max(vuint8x4 vec1, vuint8x4 vec2) { @@ -773,14 +853,19 @@ } # define VUINT8x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_AVG_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_avg(vuint8x4 vec1, vuint8x4 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x4 ones = vint8x4_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_lshift(vuint8x4 vec1, vuint8x4 vec2) { @@ -789,6 +874,8 @@ } # define VUINT8x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_rshift(vuint8x4 vec1, vuint8x4 vec2) { @@ -797,6 +884,8 @@ } # define VUINT8x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_lrshift(vuint8x4 vec1, vuint8x4 vec2) { @@ -805,6 +894,7 @@ } # define VUINT8x4_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x4_NOT_DEFINED VEC_FUNC_IMPL vuint8x4 vuint8x4_not(vuint8x4 vec) { @@ -906,6 +996,7 @@ } # define VINT8x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_CMPLT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_cmplt(vint8x8 vec1, vint8x8 vec2) { @@ -914,6 +1005,8 @@ } # define VINT8x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_cmpeq(vint8x8 vec1, vint8x8 vec2) { @@ -922,6 +1015,8 @@ } # define VINT8x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_CMPGT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_cmpgt(vint8x8 vec1, vint8x8 vec2) { @@ -930,6 +1025,8 @@ } # define VINT8x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_CMPLE_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_cmple(vint8x8 vec1, vint8x8 vec2) { @@ -938,6 +1035,8 @@ } # define VINT8x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_CMPGE_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_cmpge(vint8x8 vec1, vint8x8 vec2) { @@ -946,6 +1045,8 @@ } # define VINT8x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_MIN_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_min(vint8x8 vec1, vint8x8 vec2) { @@ -956,6 +1057,8 @@ } # define VINT8x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_MAX_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_max(vint8x8 vec1, vint8x8 vec2) { @@ -966,6 +1069,8 @@ } # define VINT8x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_AVG_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_avg(vint8x8 vec1, vint8x8 vec2) { @@ -980,6 +1085,8 @@ } # define VINT8x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_lshift(vint8x8 vec1, vuint8x8 vec2) { @@ -988,6 +1095,8 @@ } # define VINT8x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_rshift(vint8x8 vec1, vuint8x8 vec2) { @@ -996,6 +1105,8 @@ } # define VINT8x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_lrshift(vint8x8 vec1, vuint8x8 vec2) { @@ -1004,6 +1115,7 @@ } # define VINT8x8_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x8_NOT_DEFINED VEC_FUNC_IMPL vint8x8 vint8x8_not(vint8x8 vec) { @@ -1105,6 +1217,7 @@ } # define VUINT8x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_cmplt(vuint8x8 vec1, vuint8x8 vec2) { @@ -1113,6 +1226,8 @@ } # define VUINT8x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpeq(vuint8x8 vec1, vuint8x8 vec2) { @@ -1121,6 +1236,8 @@ } # define VUINT8x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpgt(vuint8x8 vec1, vuint8x8 vec2) { @@ -1129,6 +1246,8 @@ } # define VUINT8x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_cmple(vuint8x8 vec1, vuint8x8 vec2) { @@ -1137,6 +1256,8 @@ } # define VUINT8x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpge(vuint8x8 vec1, vuint8x8 vec2) { @@ -1145,6 +1266,8 @@ } # define VUINT8x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_MIN_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_min(vuint8x8 vec1, vuint8x8 vec2) { @@ -1155,6 +1278,8 @@ } # define VUINT8x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_MAX_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_max(vuint8x8 vec1, vuint8x8 vec2) { @@ -1165,14 +1290,19 @@ } # define VUINT8x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_AVG_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_avg(vuint8x8 vec1, vuint8x8 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x8 ones = vint8x8_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_lshift(vuint8x8 vec1, vuint8x8 vec2) { @@ -1181,6 +1311,8 @@ } # define VUINT8x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_rshift(vuint8x8 vec1, vuint8x8 vec2) { @@ -1189,6 +1321,8 @@ } # define VUINT8x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_lrshift(vuint8x8 vec1, vuint8x8 vec2) { @@ -1197,6 +1331,7 @@ } # define VUINT8x8_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x8_NOT_DEFINED VEC_FUNC_IMPL vuint8x8 vuint8x8_not(vuint8x8 vec) { @@ -1298,6 +1433,7 @@ } # define VINT8x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_CMPLT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2) { @@ -1306,6 +1442,8 @@ } # define VINT8x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2) { @@ -1314,6 +1452,8 @@ } # define VINT8x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_CMPGT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2) { @@ -1322,6 +1462,8 @@ } # define VINT8x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_CMPLE_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_cmple(vint8x16 vec1, vint8x16 vec2) { @@ -1330,6 +1472,8 @@ } # define VINT8x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_CMPGE_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_cmpge(vint8x16 vec1, vint8x16 vec2) { @@ -1338,6 +1482,8 @@ } # define VINT8x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_MIN_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2) { @@ -1348,6 +1494,8 @@ } # define VINT8x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_MAX_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2) { @@ -1358,6 +1506,8 @@ } # define VINT8x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_AVG_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2) { @@ -1372,6 +1522,8 @@ } # define VINT8x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2) { @@ -1380,6 +1532,8 @@ } # define VINT8x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2) { @@ -1388,6 +1542,8 @@ } # define VINT8x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2) { @@ -1396,6 +1552,7 @@ } # define VINT8x16_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x16_NOT_DEFINED VEC_FUNC_IMPL vint8x16 vint8x16_not(vint8x16 vec) { @@ -1497,6 +1654,7 @@ } # define VUINT8x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2) { @@ -1505,6 +1663,8 @@ } # define VUINT8x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2) { @@ -1513,6 +1673,8 @@ } # define VUINT8x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2) { @@ -1521,6 +1683,8 @@ } # define VUINT8x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_cmple(vuint8x16 vec1, vuint8x16 vec2) { @@ -1529,6 +1693,8 @@ } # define VUINT8x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpge(vuint8x16 vec1, vuint8x16 vec2) { @@ -1537,6 +1703,8 @@ } # define VUINT8x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_MIN_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2) { @@ -1547,6 +1715,8 @@ } # define VUINT8x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_MAX_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2) { @@ -1557,14 +1727,19 @@ } # define VUINT8x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_AVG_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x16 ones = vint8x16_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2) { @@ -1573,6 +1748,8 @@ } # define VUINT8x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2) { @@ -1581,6 +1758,8 @@ } # define VUINT8x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2) { @@ -1589,6 +1768,7 @@ } # define VUINT8x16_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x16_NOT_DEFINED VEC_FUNC_IMPL vuint8x16 vuint8x16_not(vuint8x16 vec) { @@ -1690,6 +1870,7 @@ } # define VINT8x32_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_CMPLT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_cmplt(vint8x32 vec1, vint8x32 vec2) { @@ -1698,6 +1879,8 @@ } # define VINT8x32_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_cmpeq(vint8x32 vec1, vint8x32 vec2) { @@ -1706,6 +1889,8 @@ } # define VINT8x32_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_CMPGT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_cmpgt(vint8x32 vec1, vint8x32 vec2) { @@ -1714,6 +1899,8 @@ } # define VINT8x32_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_CMPLE_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_cmple(vint8x32 vec1, vint8x32 vec2) { @@ -1722,6 +1909,8 @@ } # define VINT8x32_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_CMPGE_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_cmpge(vint8x32 vec1, vint8x32 vec2) { @@ -1730,6 +1919,8 @@ } # define VINT8x32_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_MIN_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_min(vint8x32 vec1, vint8x32 vec2) { @@ -1740,6 +1931,8 @@ } # define VINT8x32_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_MAX_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_max(vint8x32 vec1, vint8x32 vec2) { @@ -1750,6 +1943,8 @@ } # define VINT8x32_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_AVG_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_avg(vint8x32 vec1, vint8x32 vec2) { @@ -1764,6 +1959,8 @@ } # define VINT8x32_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_lshift(vint8x32 vec1, vuint8x32 vec2) { @@ -1772,6 +1969,8 @@ } # define VINT8x32_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_rshift(vint8x32 vec1, vuint8x32 vec2) { @@ -1780,6 +1979,8 @@ } # define VINT8x32_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x32_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_lrshift(vint8x32 vec1, vuint8x32 vec2) { @@ -1788,6 +1989,7 @@ } # define VINT8x32_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x32_NOT_DEFINED VEC_FUNC_IMPL vint8x32 vint8x32_not(vint8x32 vec) { @@ -1889,6 +2091,7 @@ } # define VUINT8x32_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_cmplt(vuint8x32 vec1, vuint8x32 vec2) { @@ -1897,6 +2100,8 @@ } # define VUINT8x32_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpeq(vuint8x32 vec1, vuint8x32 vec2) { @@ -1905,6 +2110,8 @@ } # define VUINT8x32_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpgt(vuint8x32 vec1, vuint8x32 vec2) { @@ -1913,6 +2120,8 @@ } # define VUINT8x32_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_cmple(vuint8x32 vec1, vuint8x32 vec2) { @@ -1921,6 +2130,8 @@ } # define VUINT8x32_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpge(vuint8x32 vec1, vuint8x32 vec2) { @@ -1929,6 +2140,8 @@ } # define VUINT8x32_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_MIN_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_min(vuint8x32 vec1, vuint8x32 vec2) { @@ -1939,6 +2152,8 @@ } # define VUINT8x32_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_MAX_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_max(vuint8x32 vec1, vuint8x32 vec2) { @@ -1949,14 +2164,19 @@ } # define VUINT8x32_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_AVG_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_avg(vuint8x32 vec1, vuint8x32 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x32 ones = vint8x32_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x32_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_lshift(vuint8x32 vec1, vuint8x32 vec2) { @@ -1965,6 +2185,8 @@ } # define VUINT8x32_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_rshift(vuint8x32 vec1, vuint8x32 vec2) { @@ -1973,6 +2195,8 @@ } # define VUINT8x32_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x32_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_lrshift(vuint8x32 vec1, vuint8x32 vec2) { @@ -1981,6 +2205,7 @@ } # define VUINT8x32_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x32_NOT_DEFINED VEC_FUNC_IMPL vuint8x32 vuint8x32_not(vuint8x32 vec) { @@ -2082,6 +2307,7 @@ } # define VINT8x64_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_CMPLT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_cmplt(vint8x64 vec1, vint8x64 vec2) { @@ -2090,6 +2316,8 @@ } # define VINT8x64_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_CMPEQ_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_cmpeq(vint8x64 vec1, vint8x64 vec2) { @@ -2098,6 +2326,8 @@ } # define VINT8x64_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_CMPGT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_cmpgt(vint8x64 vec1, vint8x64 vec2) { @@ -2106,6 +2336,8 @@ } # define VINT8x64_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_CMPLE_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_cmple(vint8x64 vec1, vint8x64 vec2) { @@ -2114,6 +2346,8 @@ } # define VINT8x64_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_CMPGE_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_cmpge(vint8x64 vec1, vint8x64 vec2) { @@ -2122,6 +2356,8 @@ } # define VINT8x64_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_MIN_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_min(vint8x64 vec1, vint8x64 vec2) { @@ -2132,6 +2368,8 @@ } # define VINT8x64_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_MAX_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_max(vint8x64 vec1, vint8x64 vec2) { @@ -2142,6 +2380,8 @@ } # define VINT8x64_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_AVG_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_avg(vint8x64 vec1, vint8x64 vec2) { @@ -2156,6 +2396,8 @@ } # define VINT8x64_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_LSHIFT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_lshift(vint8x64 vec1, vuint8x64 vec2) { @@ -2164,6 +2406,8 @@ } # define VINT8x64_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_RSHIFT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_rshift(vint8x64 vec1, vuint8x64 vec2) { @@ -2172,6 +2416,8 @@ } # define VINT8x64_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT8x64_LRSHIFT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_lrshift(vint8x64 vec1, vuint8x64 vec2) { @@ -2180,6 +2426,7 @@ } # define VINT8x64_LRSHIFT_DEFINED #endif +#endif #ifndef VINT8x64_NOT_DEFINED VEC_FUNC_IMPL vint8x64 vint8x64_not(vint8x64 vec) { @@ -2281,6 +2528,7 @@ } # define VUINT8x64_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_CMPLT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_cmplt(vuint8x64 vec1, vuint8x64 vec2) { @@ -2289,6 +2537,8 @@ } # define VUINT8x64_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_CMPEQ_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpeq(vuint8x64 vec1, vuint8x64 vec2) { @@ -2297,6 +2547,8 @@ } # define VUINT8x64_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_CMPGT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpgt(vuint8x64 vec1, vuint8x64 vec2) { @@ -2305,6 +2557,8 @@ } # define VUINT8x64_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_CMPLE_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_cmple(vuint8x64 vec1, vuint8x64 vec2) { @@ -2313,6 +2567,8 @@ } # define VUINT8x64_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_CMPGE_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpge(vuint8x64 vec1, vuint8x64 vec2) { @@ -2321,6 +2577,8 @@ } # define VUINT8x64_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_MIN_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_min(vuint8x64 vec1, vuint8x64 vec2) { @@ -2331,6 +2589,8 @@ } # define VUINT8x64_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_MAX_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_max(vuint8x64 vec1, vuint8x64 vec2) { @@ -2341,14 +2601,19 @@ } # define VUINT8x64_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_AVG_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_avg(vuint8x64 vec1, vuint8x64 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint8x64 ones = vint8x64_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT8x64_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_LSHIFT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_lshift(vuint8x64 vec1, vuint8x64 vec2) { @@ -2357,6 +2622,8 @@ } # define VUINT8x64_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_RSHIFT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_rshift(vuint8x64 vec1, vuint8x64 vec2) { @@ -2365,6 +2632,8 @@ } # define VUINT8x64_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT8x64_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_lrshift(vuint8x64 vec1, vuint8x64 vec2) { @@ -2373,6 +2642,7 @@ } # define VUINT8x64_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT8x64_NOT_DEFINED VEC_FUNC_IMPL vuint8x64 vuint8x64_not(vuint8x64 vec) { @@ -2474,6 +2744,7 @@ } # define VINT16x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_CMPLT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_cmplt(vint16x2 vec1, vint16x2 vec2) { @@ -2482,6 +2753,8 @@ } # define VINT16x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_CMPEQ_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_cmpeq(vint16x2 vec1, vint16x2 vec2) { @@ -2490,6 +2763,8 @@ } # define VINT16x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_CMPGT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_cmpgt(vint16x2 vec1, vint16x2 vec2) { @@ -2498,6 +2773,8 @@ } # define VINT16x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_CMPLE_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_cmple(vint16x2 vec1, vint16x2 vec2) { @@ -2506,6 +2783,8 @@ } # define VINT16x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_CMPGE_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_cmpge(vint16x2 vec1, vint16x2 vec2) { @@ -2514,6 +2793,8 @@ } # define VINT16x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_MIN_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_min(vint16x2 vec1, vint16x2 vec2) { @@ -2524,6 +2805,8 @@ } # define VINT16x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_MAX_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_max(vint16x2 vec1, vint16x2 vec2) { @@ -2534,6 +2817,8 @@ } # define VINT16x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_AVG_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_avg(vint16x2 vec1, vint16x2 vec2) { @@ -2548,6 +2833,8 @@ } # define VINT16x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_LSHIFT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_lshift(vint16x2 vec1, vuint16x2 vec2) { @@ -2556,6 +2843,8 @@ } # define VINT16x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_RSHIFT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_rshift(vint16x2 vec1, vuint16x2 vec2) { @@ -2564,6 +2853,8 @@ } # define VINT16x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_lrshift(vint16x2 vec1, vuint16x2 vec2) { @@ -2572,6 +2863,7 @@ } # define VINT16x2_LRSHIFT_DEFINED #endif +#endif #ifndef VINT16x2_NOT_DEFINED VEC_FUNC_IMPL vint16x2 vint16x2_not(vint16x2 vec) { @@ -2673,6 +2965,7 @@ } # define VUINT16x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_CMPLT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_cmplt(vuint16x2 vec1, vuint16x2 vec2) { @@ -2681,6 +2974,8 @@ } # define VUINT16x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_CMPEQ_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpeq(vuint16x2 vec1, vuint16x2 vec2) { @@ -2689,6 +2984,8 @@ } # define VUINT16x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_CMPGT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpgt(vuint16x2 vec1, vuint16x2 vec2) { @@ -2697,6 +2994,8 @@ } # define VUINT16x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_CMPLE_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_cmple(vuint16x2 vec1, vuint16x2 vec2) { @@ -2705,6 +3004,8 @@ } # define VUINT16x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_CMPGE_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpge(vuint16x2 vec1, vuint16x2 vec2) { @@ -2713,6 +3014,8 @@ } # define VUINT16x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_MIN_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_min(vuint16x2 vec1, vuint16x2 vec2) { @@ -2723,6 +3026,8 @@ } # define VUINT16x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_MAX_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_max(vuint16x2 vec1, vuint16x2 vec2) { @@ -2733,14 +3038,19 @@ } # define VUINT16x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_AVG_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_avg(vuint16x2 vec1, vuint16x2 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint16x2 ones = vint16x2_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT16x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_LSHIFT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_lshift(vuint16x2 vec1, vuint16x2 vec2) { @@ -2749,6 +3059,8 @@ } # define VUINT16x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_RSHIFT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_rshift(vuint16x2 vec1, vuint16x2 vec2) { @@ -2757,6 +3069,8 @@ } # define VUINT16x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_lrshift(vuint16x2 vec1, vuint16x2 vec2) { @@ -2765,6 +3079,7 @@ } # define VUINT16x2_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT16x2_NOT_DEFINED VEC_FUNC_IMPL vuint16x2 vuint16x2_not(vuint16x2 vec) { @@ -2866,6 +3181,7 @@ } # define VINT16x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_CMPLT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_cmplt(vint16x4 vec1, vint16x4 vec2) { @@ -2874,6 +3190,8 @@ } # define VINT16x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_CMPEQ_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_cmpeq(vint16x4 vec1, vint16x4 vec2) { @@ -2882,6 +3200,8 @@ } # define VINT16x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_CMPGT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_cmpgt(vint16x4 vec1, vint16x4 vec2) { @@ -2890,6 +3210,8 @@ } # define VINT16x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_CMPLE_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_cmple(vint16x4 vec1, vint16x4 vec2) { @@ -2898,6 +3220,8 @@ } # define VINT16x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_CMPGE_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_cmpge(vint16x4 vec1, vint16x4 vec2) { @@ -2906,6 +3230,8 @@ } # define VINT16x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_MIN_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_min(vint16x4 vec1, vint16x4 vec2) { @@ -2916,6 +3242,8 @@ } # define VINT16x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_MAX_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_max(vint16x4 vec1, vint16x4 vec2) { @@ -2926,6 +3254,8 @@ } # define VINT16x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_AVG_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_avg(vint16x4 vec1, vint16x4 vec2) { @@ -2940,6 +3270,8 @@ } # define VINT16x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_LSHIFT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_lshift(vint16x4 vec1, vuint16x4 vec2) { @@ -2948,6 +3280,8 @@ } # define VINT16x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_RSHIFT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_rshift(vint16x4 vec1, vuint16x4 vec2) { @@ -2956,6 +3290,8 @@ } # define VINT16x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_lrshift(vint16x4 vec1, vuint16x4 vec2) { @@ -2964,6 +3300,7 @@ } # define VINT16x4_LRSHIFT_DEFINED #endif +#endif #ifndef VINT16x4_NOT_DEFINED VEC_FUNC_IMPL vint16x4 vint16x4_not(vint16x4 vec) { @@ -3065,6 +3402,7 @@ } # define VUINT16x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_CMPLT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_cmplt(vuint16x4 vec1, vuint16x4 vec2) { @@ -3073,6 +3411,8 @@ } # define VUINT16x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_CMPEQ_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpeq(vuint16x4 vec1, vuint16x4 vec2) { @@ -3081,6 +3421,8 @@ } # define VUINT16x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_CMPGT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpgt(vuint16x4 vec1, vuint16x4 vec2) { @@ -3089,6 +3431,8 @@ } # define VUINT16x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_CMPLE_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_cmple(vuint16x4 vec1, vuint16x4 vec2) { @@ -3097,6 +3441,8 @@ } # define VUINT16x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_CMPGE_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpge(vuint16x4 vec1, vuint16x4 vec2) { @@ -3105,6 +3451,8 @@ } # define VUINT16x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_MIN_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_min(vuint16x4 vec1, vuint16x4 vec2) { @@ -3115,6 +3463,8 @@ } # define VUINT16x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_MAX_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_max(vuint16x4 vec1, vuint16x4 vec2) { @@ -3125,14 +3475,19 @@ } # define VUINT16x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_AVG_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_avg(vuint16x4 vec1, vuint16x4 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint16x4 ones = vint16x4_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT16x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_LSHIFT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_lshift(vuint16x4 vec1, vuint16x4 vec2) { @@ -3141,6 +3496,8 @@ } # define VUINT16x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_RSHIFT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_rshift(vuint16x4 vec1, vuint16x4 vec2) { @@ -3149,6 +3506,8 @@ } # define VUINT16x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_lrshift(vuint16x4 vec1, vuint16x4 vec2) { @@ -3157,6 +3516,7 @@ } # define VUINT16x4_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT16x4_NOT_DEFINED VEC_FUNC_IMPL vuint16x4 vuint16x4_not(vuint16x4 vec) { @@ -3258,6 +3618,7 @@ } # define VINT16x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_CMPLT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2) { @@ -3266,6 +3627,8 @@ } # define VINT16x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_CMPEQ_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2) { @@ -3274,6 +3637,8 @@ } # define VINT16x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_CMPGT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2) { @@ -3282,6 +3647,8 @@ } # define VINT16x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_CMPLE_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_cmple(vint16x8 vec1, vint16x8 vec2) { @@ -3290,6 +3657,8 @@ } # define VINT16x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_CMPGE_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_cmpge(vint16x8 vec1, vint16x8 vec2) { @@ -3298,6 +3667,8 @@ } # define VINT16x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_MIN_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2) { @@ -3308,6 +3679,8 @@ } # define VINT16x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_MAX_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2) { @@ -3318,6 +3691,8 @@ } # define VINT16x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_AVG_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2) { @@ -3332,6 +3707,8 @@ } # define VINT16x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_LSHIFT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2) { @@ -3340,6 +3717,8 @@ } # define VINT16x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_RSHIFT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2) { @@ -3348,6 +3727,8 @@ } # define VINT16x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2) { @@ -3356,6 +3737,7 @@ } # define VINT16x8_LRSHIFT_DEFINED #endif +#endif #ifndef VINT16x8_NOT_DEFINED VEC_FUNC_IMPL vint16x8 vint16x8_not(vint16x8 vec) { @@ -3457,6 +3839,7 @@ } # define VUINT16x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_CMPLT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2) { @@ -3465,6 +3848,8 @@ } # define VUINT16x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_CMPEQ_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2) { @@ -3473,6 +3858,8 @@ } # define VUINT16x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_CMPGT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2) { @@ -3481,6 +3868,8 @@ } # define VUINT16x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_CMPLE_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_cmple(vuint16x8 vec1, vuint16x8 vec2) { @@ -3489,6 +3878,8 @@ } # define VUINT16x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_CMPGE_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpge(vuint16x8 vec1, vuint16x8 vec2) { @@ -3497,6 +3888,8 @@ } # define VUINT16x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_MIN_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2) { @@ -3507,6 +3900,8 @@ } # define VUINT16x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_MAX_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2) { @@ -3517,14 +3912,19 @@ } # define VUINT16x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_AVG_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint16x8 ones = vint16x8_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT16x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_LSHIFT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2) { @@ -3533,6 +3933,8 @@ } # define VUINT16x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_RSHIFT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2) { @@ -3541,6 +3943,8 @@ } # define VUINT16x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2) { @@ -3549,6 +3953,7 @@ } # define VUINT16x8_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT16x8_NOT_DEFINED VEC_FUNC_IMPL vuint16x8 vuint16x8_not(vuint16x8 vec) { @@ -3650,6 +4055,7 @@ } # define VINT16x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_CMPLT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_cmplt(vint16x16 vec1, vint16x16 vec2) { @@ -3658,6 +4064,8 @@ } # define VINT16x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_CMPEQ_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_cmpeq(vint16x16 vec1, vint16x16 vec2) { @@ -3666,6 +4074,8 @@ } # define VINT16x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_CMPGT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_cmpgt(vint16x16 vec1, vint16x16 vec2) { @@ -3674,6 +4084,8 @@ } # define VINT16x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_CMPLE_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_cmple(vint16x16 vec1, vint16x16 vec2) { @@ -3682,6 +4094,8 @@ } # define VINT16x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_CMPGE_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_cmpge(vint16x16 vec1, vint16x16 vec2) { @@ -3690,6 +4104,8 @@ } # define VINT16x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_MIN_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_min(vint16x16 vec1, vint16x16 vec2) { @@ -3700,6 +4116,8 @@ } # define VINT16x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_MAX_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_max(vint16x16 vec1, vint16x16 vec2) { @@ -3710,6 +4128,8 @@ } # define VINT16x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_AVG_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_avg(vint16x16 vec1, vint16x16 vec2) { @@ -3724,6 +4144,8 @@ } # define VINT16x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_LSHIFT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_lshift(vint16x16 vec1, vuint16x16 vec2) { @@ -3732,6 +4154,8 @@ } # define VINT16x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_RSHIFT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_rshift(vint16x16 vec1, vuint16x16 vec2) { @@ -3740,6 +4164,8 @@ } # define VINT16x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_lrshift(vint16x16 vec1, vuint16x16 vec2) { @@ -3748,6 +4174,7 @@ } # define VINT16x16_LRSHIFT_DEFINED #endif +#endif #ifndef VINT16x16_NOT_DEFINED VEC_FUNC_IMPL vint16x16 vint16x16_not(vint16x16 vec) { @@ -3849,6 +4276,7 @@ } # define VUINT16x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_CMPLT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_cmplt(vuint16x16 vec1, vuint16x16 vec2) { @@ -3857,6 +4285,8 @@ } # define VUINT16x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_CMPEQ_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpeq(vuint16x16 vec1, vuint16x16 vec2) { @@ -3865,6 +4295,8 @@ } # define VUINT16x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_CMPGT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpgt(vuint16x16 vec1, vuint16x16 vec2) { @@ -3873,6 +4305,8 @@ } # define VUINT16x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_CMPLE_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_cmple(vuint16x16 vec1, vuint16x16 vec2) { @@ -3881,6 +4315,8 @@ } # define VUINT16x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_CMPGE_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpge(vuint16x16 vec1, vuint16x16 vec2) { @@ -3889,6 +4325,8 @@ } # define VUINT16x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_MIN_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_min(vuint16x16 vec1, vuint16x16 vec2) { @@ -3899,6 +4337,8 @@ } # define VUINT16x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_MAX_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_max(vuint16x16 vec1, vuint16x16 vec2) { @@ -3909,14 +4349,19 @@ } # define VUINT16x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_AVG_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_avg(vuint16x16 vec1, vuint16x16 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint16x16 ones = vint16x16_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT16x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_LSHIFT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_lshift(vuint16x16 vec1, vuint16x16 vec2) { @@ -3925,6 +4370,8 @@ } # define VUINT16x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_RSHIFT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_rshift(vuint16x16 vec1, vuint16x16 vec2) { @@ -3933,6 +4380,8 @@ } # define VUINT16x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_lrshift(vuint16x16 vec1, vuint16x16 vec2) { @@ -3941,6 +4390,7 @@ } # define VUINT16x16_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT16x16_NOT_DEFINED VEC_FUNC_IMPL vuint16x16 vuint16x16_not(vuint16x16 vec) { @@ -4042,6 +4492,7 @@ } # define VINT16x32_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_CMPLT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_cmplt(vint16x32 vec1, vint16x32 vec2) { @@ -4050,6 +4501,8 @@ } # define VINT16x32_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_CMPEQ_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_cmpeq(vint16x32 vec1, vint16x32 vec2) { @@ -4058,6 +4511,8 @@ } # define VINT16x32_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_CMPGT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_cmpgt(vint16x32 vec1, vint16x32 vec2) { @@ -4066,6 +4521,8 @@ } # define VINT16x32_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_CMPLE_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_cmple(vint16x32 vec1, vint16x32 vec2) { @@ -4074,6 +4531,8 @@ } # define VINT16x32_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_CMPGE_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_cmpge(vint16x32 vec1, vint16x32 vec2) { @@ -4082,6 +4541,8 @@ } # define VINT16x32_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_MIN_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_min(vint16x32 vec1, vint16x32 vec2) { @@ -4092,6 +4553,8 @@ } # define VINT16x32_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_MAX_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_max(vint16x32 vec1, vint16x32 vec2) { @@ -4102,6 +4565,8 @@ } # define VINT16x32_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_AVG_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_avg(vint16x32 vec1, vint16x32 vec2) { @@ -4116,6 +4581,8 @@ } # define VINT16x32_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_LSHIFT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_lshift(vint16x32 vec1, vuint16x32 vec2) { @@ -4124,6 +4591,8 @@ } # define VINT16x32_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_RSHIFT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_rshift(vint16x32 vec1, vuint16x32 vec2) { @@ -4132,6 +4601,8 @@ } # define VINT16x32_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT16x32_LRSHIFT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_lrshift(vint16x32 vec1, vuint16x32 vec2) { @@ -4140,6 +4611,7 @@ } # define VINT16x32_LRSHIFT_DEFINED #endif +#endif #ifndef VINT16x32_NOT_DEFINED VEC_FUNC_IMPL vint16x32 vint16x32_not(vint16x32 vec) { @@ -4241,6 +4713,7 @@ } # define VUINT16x32_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_CMPLT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_cmplt(vuint16x32 vec1, vuint16x32 vec2) { @@ -4249,6 +4722,8 @@ } # define VUINT16x32_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_CMPEQ_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpeq(vuint16x32 vec1, vuint16x32 vec2) { @@ -4257,6 +4732,8 @@ } # define VUINT16x32_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_CMPGT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpgt(vuint16x32 vec1, vuint16x32 vec2) { @@ -4265,6 +4742,8 @@ } # define VUINT16x32_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_CMPLE_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_cmple(vuint16x32 vec1, vuint16x32 vec2) { @@ -4273,6 +4752,8 @@ } # define VUINT16x32_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_CMPGE_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpge(vuint16x32 vec1, vuint16x32 vec2) { @@ -4281,6 +4762,8 @@ } # define VUINT16x32_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_MIN_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_min(vuint16x32 vec1, vuint16x32 vec2) { @@ -4291,6 +4774,8 @@ } # define VUINT16x32_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_MAX_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_max(vuint16x32 vec1, vuint16x32 vec2) { @@ -4301,14 +4786,19 @@ } # define VUINT16x32_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_AVG_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_avg(vuint16x32 vec1, vuint16x32 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint16x32 ones = vint16x32_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT16x32_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_LSHIFT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_lshift(vuint16x32 vec1, vuint16x32 vec2) { @@ -4317,6 +4807,8 @@ } # define VUINT16x32_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_RSHIFT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_rshift(vuint16x32 vec1, vuint16x32 vec2) { @@ -4325,6 +4817,8 @@ } # define VUINT16x32_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT16x32_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_lrshift(vuint16x32 vec1, vuint16x32 vec2) { @@ -4333,6 +4827,7 @@ } # define VUINT16x32_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT16x32_NOT_DEFINED VEC_FUNC_IMPL vuint16x32 vuint16x32_not(vuint16x32 vec) { @@ -4434,6 +4929,7 @@ } # define VINT32x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_CMPLT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_cmplt(vint32x2 vec1, vint32x2 vec2) { @@ -4442,6 +4938,8 @@ } # define VINT32x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_CMPEQ_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_cmpeq(vint32x2 vec1, vint32x2 vec2) { @@ -4450,6 +4948,8 @@ } # define VINT32x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_CMPGT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_cmpgt(vint32x2 vec1, vint32x2 vec2) { @@ -4458,6 +4958,8 @@ } # define VINT32x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_CMPLE_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_cmple(vint32x2 vec1, vint32x2 vec2) { @@ -4466,6 +4968,8 @@ } # define VINT32x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_CMPGE_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_cmpge(vint32x2 vec1, vint32x2 vec2) { @@ -4474,6 +4978,8 @@ } # define VINT32x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_MIN_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_min(vint32x2 vec1, vint32x2 vec2) { @@ -4484,6 +4990,8 @@ } # define VINT32x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_MAX_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_max(vint32x2 vec1, vint32x2 vec2) { @@ -4494,6 +5002,8 @@ } # define VINT32x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_AVG_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_avg(vint32x2 vec1, vint32x2 vec2) { @@ -4508,6 +5018,8 @@ } # define VINT32x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_LSHIFT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_lshift(vint32x2 vec1, vuint32x2 vec2) { @@ -4516,6 +5028,8 @@ } # define VINT32x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_RSHIFT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_rshift(vint32x2 vec1, vuint32x2 vec2) { @@ -4524,6 +5038,8 @@ } # define VINT32x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_lrshift(vint32x2 vec1, vuint32x2 vec2) { @@ -4532,6 +5048,7 @@ } # define VINT32x2_LRSHIFT_DEFINED #endif +#endif #ifndef VINT32x2_NOT_DEFINED VEC_FUNC_IMPL vint32x2 vint32x2_not(vint32x2 vec) { @@ -4633,6 +5150,7 @@ } # define VUINT32x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_CMPLT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_cmplt(vuint32x2 vec1, vuint32x2 vec2) { @@ -4641,6 +5159,8 @@ } # define VUINT32x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_CMPEQ_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpeq(vuint32x2 vec1, vuint32x2 vec2) { @@ -4649,6 +5169,8 @@ } # define VUINT32x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_CMPGT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpgt(vuint32x2 vec1, vuint32x2 vec2) { @@ -4657,6 +5179,8 @@ } # define VUINT32x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_CMPLE_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_cmple(vuint32x2 vec1, vuint32x2 vec2) { @@ -4665,6 +5189,8 @@ } # define VUINT32x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_CMPGE_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpge(vuint32x2 vec1, vuint32x2 vec2) { @@ -4673,6 +5199,8 @@ } # define VUINT32x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_MIN_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_min(vuint32x2 vec1, vuint32x2 vec2) { @@ -4683,6 +5211,8 @@ } # define VUINT32x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_MAX_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_max(vuint32x2 vec1, vuint32x2 vec2) { @@ -4693,14 +5223,19 @@ } # define VUINT32x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_AVG_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_avg(vuint32x2 vec1, vuint32x2 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint32x2 ones = vint32x2_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT32x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_LSHIFT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_lshift(vuint32x2 vec1, vuint32x2 vec2) { @@ -4709,6 +5244,8 @@ } # define VUINT32x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_RSHIFT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_rshift(vuint32x2 vec1, vuint32x2 vec2) { @@ -4717,6 +5254,8 @@ } # define VUINT32x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_lrshift(vuint32x2 vec1, vuint32x2 vec2) { @@ -4725,6 +5264,7 @@ } # define VUINT32x2_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT32x2_NOT_DEFINED VEC_FUNC_IMPL vuint32x2 vuint32x2_not(vuint32x2 vec) { @@ -4826,6 +5366,7 @@ } # define VINT32x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_CMPLT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2) { @@ -4834,6 +5375,8 @@ } # define VINT32x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_CMPEQ_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2) { @@ -4842,6 +5385,8 @@ } # define VINT32x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_CMPGT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2) { @@ -4850,6 +5395,8 @@ } # define VINT32x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_CMPLE_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_cmple(vint32x4 vec1, vint32x4 vec2) { @@ -4858,6 +5405,8 @@ } # define VINT32x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_CMPGE_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_cmpge(vint32x4 vec1, vint32x4 vec2) { @@ -4866,6 +5415,8 @@ } # define VINT32x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_MIN_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2) { @@ -4876,6 +5427,8 @@ } # define VINT32x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_MAX_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2) { @@ -4886,6 +5439,8 @@ } # define VINT32x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_AVG_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2) { @@ -4900,6 +5455,8 @@ } # define VINT32x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_LSHIFT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2) { @@ -4908,6 +5465,8 @@ } # define VINT32x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_RSHIFT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2) { @@ -4916,6 +5475,8 @@ } # define VINT32x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2) { @@ -4924,6 +5485,7 @@ } # define VINT32x4_LRSHIFT_DEFINED #endif +#endif #ifndef VINT32x4_NOT_DEFINED VEC_FUNC_IMPL vint32x4 vint32x4_not(vint32x4 vec) { @@ -5025,6 +5587,7 @@ } # define VUINT32x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_CMPLT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2) { @@ -5033,6 +5596,8 @@ } # define VUINT32x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_CMPEQ_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2) { @@ -5041,6 +5606,8 @@ } # define VUINT32x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_CMPGT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2) { @@ -5049,6 +5616,8 @@ } # define VUINT32x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_CMPLE_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_cmple(vuint32x4 vec1, vuint32x4 vec2) { @@ -5057,6 +5626,8 @@ } # define VUINT32x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_CMPGE_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpge(vuint32x4 vec1, vuint32x4 vec2) { @@ -5065,6 +5636,8 @@ } # define VUINT32x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_MIN_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2) { @@ -5075,6 +5648,8 @@ } # define VUINT32x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_MAX_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2) { @@ -5085,14 +5660,19 @@ } # define VUINT32x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_AVG_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint32x4 ones = vint32x4_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT32x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_LSHIFT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2) { @@ -5101,6 +5681,8 @@ } # define VUINT32x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_RSHIFT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2) { @@ -5109,6 +5691,8 @@ } # define VUINT32x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2) { @@ -5117,6 +5701,7 @@ } # define VUINT32x4_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT32x4_NOT_DEFINED VEC_FUNC_IMPL vuint32x4 vuint32x4_not(vuint32x4 vec) { @@ -5218,6 +5803,7 @@ } # define VINT32x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_CMPLT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_cmplt(vint32x8 vec1, vint32x8 vec2) { @@ -5226,6 +5812,8 @@ } # define VINT32x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_CMPEQ_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_cmpeq(vint32x8 vec1, vint32x8 vec2) { @@ -5234,6 +5822,8 @@ } # define VINT32x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_CMPGT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_cmpgt(vint32x8 vec1, vint32x8 vec2) { @@ -5242,6 +5832,8 @@ } # define VINT32x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_CMPLE_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_cmple(vint32x8 vec1, vint32x8 vec2) { @@ -5250,6 +5842,8 @@ } # define VINT32x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_CMPGE_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_cmpge(vint32x8 vec1, vint32x8 vec2) { @@ -5258,6 +5852,8 @@ } # define VINT32x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_MIN_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_min(vint32x8 vec1, vint32x8 vec2) { @@ -5268,6 +5864,8 @@ } # define VINT32x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_MAX_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_max(vint32x8 vec1, vint32x8 vec2) { @@ -5278,6 +5876,8 @@ } # define VINT32x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_AVG_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_avg(vint32x8 vec1, vint32x8 vec2) { @@ -5292,6 +5892,8 @@ } # define VINT32x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_LSHIFT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_lshift(vint32x8 vec1, vuint32x8 vec2) { @@ -5300,6 +5902,8 @@ } # define VINT32x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_RSHIFT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_rshift(vint32x8 vec1, vuint32x8 vec2) { @@ -5308,6 +5912,8 @@ } # define VINT32x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_lrshift(vint32x8 vec1, vuint32x8 vec2) { @@ -5316,6 +5922,7 @@ } # define VINT32x8_LRSHIFT_DEFINED #endif +#endif #ifndef VINT32x8_NOT_DEFINED VEC_FUNC_IMPL vint32x8 vint32x8_not(vint32x8 vec) { @@ -5417,6 +6024,7 @@ } # define VUINT32x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_CMPLT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_cmplt(vuint32x8 vec1, vuint32x8 vec2) { @@ -5425,6 +6033,8 @@ } # define VUINT32x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_CMPEQ_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpeq(vuint32x8 vec1, vuint32x8 vec2) { @@ -5433,6 +6043,8 @@ } # define VUINT32x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_CMPGT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpgt(vuint32x8 vec1, vuint32x8 vec2) { @@ -5441,6 +6053,8 @@ } # define VUINT32x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_CMPLE_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_cmple(vuint32x8 vec1, vuint32x8 vec2) { @@ -5449,6 +6063,8 @@ } # define VUINT32x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_CMPGE_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpge(vuint32x8 vec1, vuint32x8 vec2) { @@ -5457,6 +6073,8 @@ } # define VUINT32x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_MIN_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_min(vuint32x8 vec1, vuint32x8 vec2) { @@ -5467,6 +6085,8 @@ } # define VUINT32x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_MAX_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_max(vuint32x8 vec1, vuint32x8 vec2) { @@ -5477,14 +6097,19 @@ } # define VUINT32x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_AVG_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_avg(vuint32x8 vec1, vuint32x8 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint32x8 ones = vint32x8_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT32x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_LSHIFT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_lshift(vuint32x8 vec1, vuint32x8 vec2) { @@ -5493,6 +6118,8 @@ } # define VUINT32x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_RSHIFT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_rshift(vuint32x8 vec1, vuint32x8 vec2) { @@ -5501,6 +6128,8 @@ } # define VUINT32x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_lrshift(vuint32x8 vec1, vuint32x8 vec2) { @@ -5509,6 +6138,7 @@ } # define VUINT32x8_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT32x8_NOT_DEFINED VEC_FUNC_IMPL vuint32x8 vuint32x8_not(vuint32x8 vec) { @@ -5610,6 +6240,7 @@ } # define VINT32x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_CMPLT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_cmplt(vint32x16 vec1, vint32x16 vec2) { @@ -5618,6 +6249,8 @@ } # define VINT32x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_CMPEQ_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_cmpeq(vint32x16 vec1, vint32x16 vec2) { @@ -5626,6 +6259,8 @@ } # define VINT32x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_CMPGT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_cmpgt(vint32x16 vec1, vint32x16 vec2) { @@ -5634,6 +6269,8 @@ } # define VINT32x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_CMPLE_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_cmple(vint32x16 vec1, vint32x16 vec2) { @@ -5642,6 +6279,8 @@ } # define VINT32x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_CMPGE_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_cmpge(vint32x16 vec1, vint32x16 vec2) { @@ -5650,6 +6289,8 @@ } # define VINT32x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_MIN_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_min(vint32x16 vec1, vint32x16 vec2) { @@ -5660,6 +6301,8 @@ } # define VINT32x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_MAX_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_max(vint32x16 vec1, vint32x16 vec2) { @@ -5670,6 +6313,8 @@ } # define VINT32x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_AVG_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_avg(vint32x16 vec1, vint32x16 vec2) { @@ -5684,6 +6329,8 @@ } # define VINT32x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_LSHIFT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_lshift(vint32x16 vec1, vuint32x16 vec2) { @@ -5692,6 +6339,8 @@ } # define VINT32x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_RSHIFT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_rshift(vint32x16 vec1, vuint32x16 vec2) { @@ -5700,6 +6349,8 @@ } # define VINT32x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT32x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_lrshift(vint32x16 vec1, vuint32x16 vec2) { @@ -5708,6 +6359,7 @@ } # define VINT32x16_LRSHIFT_DEFINED #endif +#endif #ifndef VINT32x16_NOT_DEFINED VEC_FUNC_IMPL vint32x16 vint32x16_not(vint32x16 vec) { @@ -5809,6 +6461,7 @@ } # define VUINT32x16_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_CMPLT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_cmplt(vuint32x16 vec1, vuint32x16 vec2) { @@ -5817,6 +6470,8 @@ } # define VUINT32x16_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_CMPEQ_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpeq(vuint32x16 vec1, vuint32x16 vec2) { @@ -5825,6 +6480,8 @@ } # define VUINT32x16_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_CMPGT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpgt(vuint32x16 vec1, vuint32x16 vec2) { @@ -5833,6 +6490,8 @@ } # define VUINT32x16_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_CMPLE_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_cmple(vuint32x16 vec1, vuint32x16 vec2) { @@ -5841,6 +6500,8 @@ } # define VUINT32x16_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_CMPGE_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpge(vuint32x16 vec1, vuint32x16 vec2) { @@ -5849,6 +6510,8 @@ } # define VUINT32x16_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_MIN_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_min(vuint32x16 vec1, vuint32x16 vec2) { @@ -5859,6 +6522,8 @@ } # define VUINT32x16_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_MAX_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_max(vuint32x16 vec1, vuint32x16 vec2) { @@ -5869,14 +6534,19 @@ } # define VUINT32x16_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_AVG_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_avg(vuint32x16 vec1, vuint32x16 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint32x16 ones = vint32x16_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT32x16_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_LSHIFT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_lshift(vuint32x16 vec1, vuint32x16 vec2) { @@ -5885,6 +6555,8 @@ } # define VUINT32x16_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_RSHIFT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_rshift(vuint32x16 vec1, vuint32x16 vec2) { @@ -5893,6 +6565,8 @@ } # define VUINT32x16_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT32x16_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_lrshift(vuint32x16 vec1, vuint32x16 vec2) { @@ -5901,6 +6575,7 @@ } # define VUINT32x16_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT32x16_NOT_DEFINED VEC_FUNC_IMPL vuint32x16 vuint32x16_not(vuint32x16 vec) { @@ -6002,6 +6677,7 @@ } # define VINT64x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_CMPLT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_cmplt(vint64x2 vec1, vint64x2 vec2) { @@ -6010,6 +6686,8 @@ } # define VINT64x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_CMPEQ_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_cmpeq(vint64x2 vec1, vint64x2 vec2) { @@ -6018,6 +6696,8 @@ } # define VINT64x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_CMPGT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_cmpgt(vint64x2 vec1, vint64x2 vec2) { @@ -6026,6 +6706,8 @@ } # define VINT64x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_CMPLE_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_cmple(vint64x2 vec1, vint64x2 vec2) { @@ -6034,6 +6716,8 @@ } # define VINT64x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_CMPGE_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_cmpge(vint64x2 vec1, vint64x2 vec2) { @@ -6042,6 +6726,8 @@ } # define VINT64x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_MIN_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_min(vint64x2 vec1, vint64x2 vec2) { @@ -6052,6 +6738,8 @@ } # define VINT64x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_MAX_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_max(vint64x2 vec1, vint64x2 vec2) { @@ -6062,6 +6750,8 @@ } # define VINT64x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_AVG_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_avg(vint64x2 vec1, vint64x2 vec2) { @@ -6076,6 +6766,8 @@ } # define VINT64x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_LSHIFT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_lshift(vint64x2 vec1, vuint64x2 vec2) { @@ -6084,6 +6776,8 @@ } # define VINT64x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_RSHIFT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_rshift(vint64x2 vec1, vuint64x2 vec2) { @@ -6092,6 +6786,8 @@ } # define VINT64x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_lrshift(vint64x2 vec1, vuint64x2 vec2) { @@ -6100,6 +6796,7 @@ } # define VINT64x2_LRSHIFT_DEFINED #endif +#endif #ifndef VINT64x2_NOT_DEFINED VEC_FUNC_IMPL vint64x2 vint64x2_not(vint64x2 vec) { @@ -6201,6 +6898,7 @@ } # define VUINT64x2_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_CMPLT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_cmplt(vuint64x2 vec1, vuint64x2 vec2) { @@ -6209,6 +6907,8 @@ } # define VUINT64x2_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_CMPEQ_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpeq(vuint64x2 vec1, vuint64x2 vec2) { @@ -6217,6 +6917,8 @@ } # define VUINT64x2_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_CMPGT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpgt(vuint64x2 vec1, vuint64x2 vec2) { @@ -6225,6 +6927,8 @@ } # define VUINT64x2_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_CMPLE_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_cmple(vuint64x2 vec1, vuint64x2 vec2) { @@ -6233,6 +6937,8 @@ } # define VUINT64x2_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_CMPGE_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpge(vuint64x2 vec1, vuint64x2 vec2) { @@ -6241,6 +6947,8 @@ } # define VUINT64x2_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_MIN_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_min(vuint64x2 vec1, vuint64x2 vec2) { @@ -6251,6 +6959,8 @@ } # define VUINT64x2_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_MAX_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_max(vuint64x2 vec1, vuint64x2 vec2) { @@ -6261,14 +6971,19 @@ } # define VUINT64x2_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_AVG_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_avg(vuint64x2 vec1, vuint64x2 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint64x2 ones = vint64x2_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT64x2_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_LSHIFT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_lshift(vuint64x2 vec1, vuint64x2 vec2) { @@ -6277,6 +6992,8 @@ } # define VUINT64x2_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_RSHIFT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_rshift(vuint64x2 vec1, vuint64x2 vec2) { @@ -6285,6 +7002,8 @@ } # define VUINT64x2_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x2_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_lrshift(vuint64x2 vec1, vuint64x2 vec2) { @@ -6293,6 +7012,7 @@ } # define VUINT64x2_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT64x2_NOT_DEFINED VEC_FUNC_IMPL vuint64x2 vuint64x2_not(vuint64x2 vec) { @@ -6394,6 +7114,7 @@ } # define VINT64x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_CMPLT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_cmplt(vint64x4 vec1, vint64x4 vec2) { @@ -6402,6 +7123,8 @@ } # define VINT64x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_CMPEQ_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_cmpeq(vint64x4 vec1, vint64x4 vec2) { @@ -6410,6 +7133,8 @@ } # define VINT64x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_CMPGT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_cmpgt(vint64x4 vec1, vint64x4 vec2) { @@ -6418,6 +7143,8 @@ } # define VINT64x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_CMPLE_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_cmple(vint64x4 vec1, vint64x4 vec2) { @@ -6426,6 +7153,8 @@ } # define VINT64x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_CMPGE_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_cmpge(vint64x4 vec1, vint64x4 vec2) { @@ -6434,6 +7163,8 @@ } # define VINT64x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_MIN_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_min(vint64x4 vec1, vint64x4 vec2) { @@ -6444,6 +7175,8 @@ } # define VINT64x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_MAX_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_max(vint64x4 vec1, vint64x4 vec2) { @@ -6454,6 +7187,8 @@ } # define VINT64x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_AVG_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_avg(vint64x4 vec1, vint64x4 vec2) { @@ -6468,6 +7203,8 @@ } # define VINT64x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_LSHIFT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_lshift(vint64x4 vec1, vuint64x4 vec2) { @@ -6476,6 +7213,8 @@ } # define VINT64x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_RSHIFT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_rshift(vint64x4 vec1, vuint64x4 vec2) { @@ -6484,6 +7223,8 @@ } # define VINT64x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_lrshift(vint64x4 vec1, vuint64x4 vec2) { @@ -6492,6 +7233,7 @@ } # define VINT64x4_LRSHIFT_DEFINED #endif +#endif #ifndef VINT64x4_NOT_DEFINED VEC_FUNC_IMPL vint64x4 vint64x4_not(vint64x4 vec) { @@ -6593,6 +7335,7 @@ } # define VUINT64x4_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_CMPLT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_cmplt(vuint64x4 vec1, vuint64x4 vec2) { @@ -6601,6 +7344,8 @@ } # define VUINT64x4_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_CMPEQ_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpeq(vuint64x4 vec1, vuint64x4 vec2) { @@ -6609,6 +7354,8 @@ } # define VUINT64x4_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_CMPGT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpgt(vuint64x4 vec1, vuint64x4 vec2) { @@ -6617,6 +7364,8 @@ } # define VUINT64x4_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_CMPLE_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_cmple(vuint64x4 vec1, vuint64x4 vec2) { @@ -6625,6 +7374,8 @@ } # define VUINT64x4_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_CMPGE_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpge(vuint64x4 vec1, vuint64x4 vec2) { @@ -6633,6 +7384,8 @@ } # define VUINT64x4_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_MIN_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_min(vuint64x4 vec1, vuint64x4 vec2) { @@ -6643,6 +7396,8 @@ } # define VUINT64x4_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_MAX_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_max(vuint64x4 vec1, vuint64x4 vec2) { @@ -6653,14 +7408,19 @@ } # define VUINT64x4_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_AVG_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_avg(vuint64x4 vec1, vuint64x4 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint64x4 ones = vint64x4_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT64x4_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_LSHIFT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_lshift(vuint64x4 vec1, vuint64x4 vec2) { @@ -6669,6 +7429,8 @@ } # define VUINT64x4_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_RSHIFT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_rshift(vuint64x4 vec1, vuint64x4 vec2) { @@ -6677,6 +7439,8 @@ } # define VUINT64x4_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x4_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_lrshift(vuint64x4 vec1, vuint64x4 vec2) { @@ -6685,6 +7449,7 @@ } # define VUINT64x4_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT64x4_NOT_DEFINED VEC_FUNC_IMPL vuint64x4 vuint64x4_not(vuint64x4 vec) { @@ -6786,6 +7551,7 @@ } # define VINT64x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_CMPLT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_cmplt(vint64x8 vec1, vint64x8 vec2) { @@ -6794,6 +7560,8 @@ } # define VINT64x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_CMPEQ_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_cmpeq(vint64x8 vec1, vint64x8 vec2) { @@ -6802,6 +7570,8 @@ } # define VINT64x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_CMPGT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_cmpgt(vint64x8 vec1, vint64x8 vec2) { @@ -6810,6 +7580,8 @@ } # define VINT64x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_CMPLE_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_cmple(vint64x8 vec1, vint64x8 vec2) { @@ -6818,6 +7590,8 @@ } # define VINT64x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_CMPGE_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_cmpge(vint64x8 vec1, vint64x8 vec2) { @@ -6826,6 +7600,8 @@ } # define VINT64x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_MIN_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_min(vint64x8 vec1, vint64x8 vec2) { @@ -6836,6 +7612,8 @@ } # define VINT64x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_MAX_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_max(vint64x8 vec1, vint64x8 vec2) { @@ -6846,6 +7624,8 @@ } # define VINT64x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_AVG_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_avg(vint64x8 vec1, vint64x8 vec2) { @@ -6860,6 +7640,8 @@ } # define VINT64x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_LSHIFT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_lshift(vint64x8 vec1, vuint64x8 vec2) { @@ -6868,6 +7650,8 @@ } # define VINT64x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_RSHIFT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_rshift(vint64x8 vec1, vuint64x8 vec2) { @@ -6876,6 +7660,8 @@ } # define VINT64x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VINT64x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_lrshift(vint64x8 vec1, vuint64x8 vec2) { @@ -6884,6 +7670,7 @@ } # define VINT64x8_LRSHIFT_DEFINED #endif +#endif #ifndef VINT64x8_NOT_DEFINED VEC_FUNC_IMPL vint64x8 vint64x8_not(vint64x8 vec) { @@ -6985,6 +7772,7 @@ } # define VUINT64x8_XOR_DEFINED #endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_CMPLT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_cmplt(vuint64x8 vec1, vuint64x8 vec2) { @@ -6993,6 +7781,8 @@ } # define VUINT64x8_CMPLT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_CMPEQ_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpeq(vuint64x8 vec1, vuint64x8 vec2) { @@ -7001,6 +7791,8 @@ } # define VUINT64x8_CMPEQ_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_CMPGT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpgt(vuint64x8 vec1, vuint64x8 vec2) { @@ -7009,6 +7801,8 @@ } # define VUINT64x8_CMPGT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_CMPLE_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_cmple(vuint64x8 vec1, vuint64x8 vec2) { @@ -7017,6 +7811,8 @@ } # define VUINT64x8_CMPLE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_CMPGE_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpge(vuint64x8 vec1, vuint64x8 vec2) { @@ -7025,6 +7821,8 @@ } # define VUINT64x8_CMPGE_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_MIN_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_min(vuint64x8 vec1, vuint64x8 vec2) { @@ -7035,6 +7833,8 @@ } # define VUINT64x8_MIN_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_MAX_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_max(vuint64x8 vec1, vuint64x8 vec2) { @@ -7045,14 +7845,19 @@ } # define VUINT64x8_MAX_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_AVG_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_avg(vuint64x8 vec1, vuint64x8 vec2) { - vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1); + vint64x8 ones = vint64x8_splat(1); + vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc); return vec1; } # define VUINT64x8_AVG_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_LSHIFT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_lshift(vuint64x8 vec1, vuint64x8 vec2) { @@ -7061,6 +7866,8 @@ } # define VUINT64x8_LSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_RSHIFT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_rshift(vuint64x8 vec1, vuint64x8 vec2) { @@ -7069,6 +7876,8 @@ } # define VUINT64x8_RSHIFT_DEFINED #endif +#endif +#if VEC_GNUC_ATLEAST(4, 3, 0) #ifndef VUINT64x8_LRSHIFT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_lrshift(vuint64x8 vec1, vuint64x8 vec2) { @@ -7077,6 +7886,7 @@ } # define VUINT64x8_LRSHIFT_DEFINED #endif +#endif #ifndef VUINT64x8_NOT_DEFINED VEC_FUNC_IMPL vuint64x8 vuint64x8_not(vuint64x8 vec) {
--- a/include/vec/impl/generic.h Sun Apr 27 02:49:53 2025 -0400 +++ b/include/vec/impl/generic.h Mon Apr 28 16:31:59 2025 -0400 @@ -109,7 +109,7 @@ VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ { \ for (int i = 0; i < size; i++) \ - vec1.generic[i] = vec_##sign##avg(vec1.generic[i], vec2.generic[i]); \ + vec1.generic[i] = vec_im##sign##avg(vec1.generic[i], vec2.generic[i]); \ \ return vec1; \ } @@ -208,79 +208,6 @@ return v##sign##int##bits##x##size##_or(a, b); \ } -#define VEC_GENERIC_DBL_SPLAT(sign, bits, size, halfsize) \ - VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \ - { \ - v##sign##int##bits##x##size vec; \ - \ - vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \ - vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \ - \ - return vec; \ - } - -#define VEC_GENERIC_DBL_LOAD_EX(name, sign, bits, size, halfsize) \ - VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \ - { \ - v##sign##int##bits##x##size vec; \ - \ - vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \ - vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \ - \ - return vec; \ - } - -#define VEC_GENERIC_DBL_LOAD(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load, sign, bits, size, halfsize) -#define VEC_GENERIC_DBL_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load_aligned, sign, bits, size, halfsize) - -#define VEC_GENERIC_DBL_STORE_EX(name, sign, bits, size, halfsize) \ - VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \ - { \ - v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \ - v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \ - } - -#define VEC_GENERIC_DBL_STORE(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store, sign, bits, size, halfsize) -#define VEC_GENERIC_DBL_STORE_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store_aligned, sign, bits, size, halfsize) - -#define VEC_GENERIC_DBL_OP(name, sign, bits, size, halfsize, secondsign) \ - VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \ - { \ - vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \ - vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \ - \ - return vec1; \ - } - -#define VEC_GENERIC_DBL_ADD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(add, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_SUB(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(sub, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_MUL(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mul, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_DIV(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(div, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_MOD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mod, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_AVG(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(avg, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_LSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lshift, sign, bits, size, halfsize, u) -#define VEC_GENERIC_DBL_RSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(rshift, sign, bits, size, halfsize, u) -#define VEC_GENERIC_DBL_LRSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lrshift, sign, bits, size, halfsize, u) -#define VEC_GENERIC_DBL_AND(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(and, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_OR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(or, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_XOR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(xor, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_MIN(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(min, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_MAX(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(max, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_CMPLT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmplt, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_CMPLE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmple, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_CMPEQ(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpeq, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_CMPGE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpge, sign, bits, size, halfsize, sign) -#define VEC_GENERIC_DBL_CMPGT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpgt, sign, bits, size, halfsize, sign) - -#define VEC_GENERIC_DBL_NOT(sign, bits, size, halfsize) \ - VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \ - { \ - vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \ - vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \ - \ - return vec; \ - } - /* ------------------------------------------------------------------------ */ /* PREPROCESSOR HELL INCOMING */ @@ -494,1296 +421,6 @@ #endif -/* vuint8x4 */ - -#ifndef VINT8x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 4, 2) -# define VINT8x4_SPLAT_DEFINED -#endif - -#ifndef VINT8x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 4, 2) -# define VINT8x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT8x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 4, 2) -# define VINT8x4_LOAD_DEFINED -#endif - -#ifndef VINT8x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 4, 2) -# define VINT8x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT8x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 8, 4, 2) -# define VINT8x4_STORE_DEFINED -#endif - -#ifndef VINT8x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 8, 4, 2) -# define VINT8x4_ADD_DEFINED -#endif - -#ifndef VINT8x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 8, 4, 2) -# define VINT8x4_SUB_DEFINED -#endif - -#ifndef VINT8x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 8, 4, 2) -# define VINT8x4_MUL_DEFINED -#endif - -#ifndef VINT8x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 8, 4, 2) -# define VINT8x4_DIV_DEFINED -#endif - -#ifndef VINT8x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 8, 4, 2) -# define VINT8x4_MOD_DEFINED -#endif - -#ifndef VINT8x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 8, 4, 2) -# define VINT8x4_AVG_DEFINED -#endif - -#ifndef VINT8x4_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 8, 4, 2) -# define VINT8x4_AND_DEFINED -#endif - -#ifndef VINT8x4_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 8, 4, 2) -# define VINT8x4_OR_DEFINED -#endif - -#ifndef VINT8x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 8, 4, 2) -# define VINT8x4_XOR_DEFINED -#endif - -#ifndef VINT8x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 8, 4, 2) -# define VINT8x4_NOT_DEFINED -#endif - -#ifndef VINT8x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 4, 2) -# define VINT8x4_CMPLT_DEFINED -#endif - -#ifndef VINT8x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 4, 2) -# define VINT8x4_CMPEQ_DEFINED -#endif - -#ifndef VINT8x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 4, 2) -# define VINT8x4_CMPGT_DEFINED -#endif - -#ifndef VINT8x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 4, 2) -# define VINT8x4_CMPLE_DEFINED -#endif - -#ifndef VINT8x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 4, 2) -# define VINT8x4_CMPGE_DEFINED -#endif - -#ifndef VINT8x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 8, 4, 2) -# define VINT8x4_MIN_DEFINED -#endif - -#ifndef VINT8x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 8, 4, 2) -# define VINT8x4_MAX_DEFINED -#endif - -#ifndef VINT8x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 4, 2) -# define VINT8x4_RSHIFT_DEFINED -#endif - -#ifndef VINT8x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 4, 2) -# define VINT8x4_LRSHIFT_DEFINED -#endif - -#ifndef VINT8x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 4, 2) -# define VINT8x4_LSHIFT_DEFINED -#endif - - - -/* vint8x4 */ - -#ifndef VUINT8x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 8, 4, 2) -# define VUINT8x4_SPLAT_DEFINED -#endif - -#ifndef VUINT8x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 4, 2) -# define VUINT8x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 8, 4, 2) -# define VUINT8x4_LOAD_DEFINED -#endif - -#ifndef VUINT8x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 4, 2) -# define VUINT8x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 8, 4, 2) -# define VUINT8x4_STORE_DEFINED -#endif - -#ifndef VUINT8x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 8, 4, 2) -# define VUINT8x4_ADD_DEFINED -#endif - -#ifndef VUINT8x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 8, 4, 2) -# define VUINT8x4_SUB_DEFINED -#endif - -#ifndef VUINT8x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 8, 4, 2) -# define VUINT8x4_MUL_DEFINED -#endif - -#ifndef VUINT8x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 8, 4, 2) -# define VUINT8x4_DIV_DEFINED -#endif - -#ifndef VUINT8x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 8, 4, 2) -# define VUINT8x4_MOD_DEFINED -#endif - -#ifndef VUINT8x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 8, 4, 2) -# define VUINT8x4_AVG_DEFINED -#endif - -#ifndef VUINT8x4_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 8, 4, 2) -# define VUINT8x4_AND_DEFINED -#endif - -#ifndef VUINT8x4_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 8, 4, 2) -# define VUINT8x4_OR_DEFINED -#endif - -#ifndef VUINT8x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 8, 4, 2) -# define VUINT8x4_XOR_DEFINED -#endif - -#ifndef VUINT8x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 8, 4, 2) -# define VUINT8x4_NOT_DEFINED -#endif - -#ifndef VUINT8x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 8, 4, 2) -# define VUINT8x4_CMPLT_DEFINED -#endif - -#ifndef VUINT8x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 8, 4, 2) -# define VUINT8x4_CMPEQ_DEFINED -#endif - -#ifndef VUINT8x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 8, 4, 2) -# define VUINT8x4_CMPGT_DEFINED -#endif - -#ifndef VUINT8x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 8, 4, 2) -# define VUINT8x4_CMPLE_DEFINED -#endif - -#ifndef VUINT8x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 8, 4, 2) -# define VUINT8x4_CMPGE_DEFINED -#endif - -#ifndef VUINT8x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 8, 4, 2) -# define VUINT8x4_MIN_DEFINED -#endif - -#ifndef VUINT8x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 8, 4, 2) -# define VUINT8x4_MAX_DEFINED -#endif - -#ifndef VUINT8x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 8, 4, 2) -# define VUINT8x4_RSHIFT_DEFINED -#endif - -#ifndef VUINT8x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 8, 4, 2) -# define VUINT8x4_LRSHIFT_DEFINED -#endif - -#ifndef VUINT8x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 8, 4, 2) -# define VUINT8x4_LSHIFT_DEFINED -#endif - - - -/* vuint8x8 */ - -#ifndef VINT8x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 8, 4) -# define VINT8x8_SPLAT_DEFINED -#endif - -#ifndef VINT8x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 8, 4) -# define VINT8x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT8x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 8, 4) -# define VINT8x8_LOAD_DEFINED -#endif - -#ifndef VINT8x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 8, 4) -# define VINT8x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT8x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 8, 8, 4) -# define VINT8x8_STORE_DEFINED -#endif - -#ifndef VINT8x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 8, 8, 4) -# define VINT8x8_ADD_DEFINED -#endif - -#ifndef VINT8x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 8, 8, 4) -# define VINT8x8_SUB_DEFINED -#endif - -#ifndef VINT8x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 8, 8, 4) -# define VINT8x8_MUL_DEFINED -#endif - -#ifndef VINT8x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 8, 8, 4) -# define VINT8x8_DIV_DEFINED -#endif - -#ifndef VINT8x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 8, 8, 4) -# define VINT8x8_MOD_DEFINED -#endif - -#ifndef VINT8x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 8, 8, 4) -# define VINT8x8_AVG_DEFINED -#endif - -#ifndef VINT8x8_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 8, 8, 4) -# define VINT8x8_AND_DEFINED -#endif - -#ifndef VINT8x8_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 8, 8, 4) -# define VINT8x8_OR_DEFINED -#endif - -#ifndef VINT8x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 8, 8, 4) -# define VINT8x8_XOR_DEFINED -#endif - -#ifndef VINT8x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 8, 8, 4) -# define VINT8x8_NOT_DEFINED -#endif - -#ifndef VINT8x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 8, 4) -# define VINT8x8_CMPLT_DEFINED -#endif - -#ifndef VINT8x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 8, 4) -# define VINT8x8_CMPEQ_DEFINED -#endif - -#ifndef VINT8x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 8, 4) -# define VINT8x8_CMPGT_DEFINED -#endif - -#ifndef VINT8x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 8, 4) -# define VINT8x8_CMPLE_DEFINED -#endif - -#ifndef VINT8x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 8, 4) -# define VINT8x8_CMPGE_DEFINED -#endif - -#ifndef VINT8x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 8, 8, 4) -# define VINT8x8_MIN_DEFINED -#endif - -#ifndef VINT8x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 8, 8, 4) -# define VINT8x8_MAX_DEFINED -#endif - -#ifndef VINT8x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 8, 4) -# define VINT8x8_RSHIFT_DEFINED -#endif - -#ifndef VINT8x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 8, 4) -# define VINT8x8_LRSHIFT_DEFINED -#endif - -#ifndef VINT8x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 8, 4) -# define VINT8x8_LSHIFT_DEFINED -#endif - - - -/* vint8x8 */ - -#ifndef VUINT8x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 8, 8, 4) -# define VUINT8x8_SPLAT_DEFINED -#endif - -#ifndef VUINT8x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 8, 4) -# define VUINT8x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 8, 8, 4) -# define VUINT8x8_LOAD_DEFINED -#endif - -#ifndef VUINT8x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 8, 4) -# define VUINT8x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 8, 8, 4) -# define VUINT8x8_STORE_DEFINED -#endif - -#ifndef VUINT8x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 8, 8, 4) -# define VUINT8x8_ADD_DEFINED -#endif - -#ifndef VUINT8x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 8, 8, 4) -# define VUINT8x8_SUB_DEFINED -#endif - -#ifndef VUINT8x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 8, 8, 4) -# define VUINT8x8_MUL_DEFINED -#endif - -#ifndef VUINT8x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 8, 8, 4) -# define VUINT8x8_DIV_DEFINED -#endif - -#ifndef VUINT8x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 8, 8, 4) -# define VUINT8x8_MOD_DEFINED -#endif - -#ifndef VUINT8x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 8, 8, 4) -# define VUINT8x8_AVG_DEFINED -#endif - -#ifndef VUINT8x8_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 8, 8, 4) -# define VUINT8x8_AND_DEFINED -#endif - -#ifndef VUINT8x8_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 8, 8, 4) -# define VUINT8x8_OR_DEFINED -#endif - -#ifndef VUINT8x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 8, 8, 4) -# define VUINT8x8_XOR_DEFINED -#endif - -#ifndef VUINT8x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 8, 8, 4) -# define VUINT8x8_NOT_DEFINED -#endif - -#ifndef VUINT8x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 8, 8, 4) -# define VUINT8x8_CMPLT_DEFINED -#endif - -#ifndef VUINT8x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 8, 8, 4) -# define VUINT8x8_CMPEQ_DEFINED -#endif - -#ifndef VUINT8x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 8, 8, 4) -# define VUINT8x8_CMPGT_DEFINED -#endif - -#ifndef VUINT8x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 8, 8, 4) -# define VUINT8x8_CMPLE_DEFINED -#endif - -#ifndef VUINT8x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 8, 8, 4) -# define VUINT8x8_CMPGE_DEFINED -#endif - -#ifndef VUINT8x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 8, 8, 4) -# define VUINT8x8_MIN_DEFINED -#endif - -#ifndef VUINT8x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 8, 8, 4) -# define VUINT8x8_MAX_DEFINED -#endif - -#ifndef VUINT8x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 8, 8, 4) -# define VUINT8x8_RSHIFT_DEFINED -#endif - -#ifndef VUINT8x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 8, 8, 4) -# define VUINT8x8_LRSHIFT_DEFINED -#endif - -#ifndef VUINT8x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 8, 8, 4) -# define VUINT8x8_LSHIFT_DEFINED -#endif - - - -/* vuint8x16 */ - -#ifndef VINT8x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 16, 8) -# define VINT8x16_SPLAT_DEFINED -#endif - -#ifndef VINT8x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 16, 8) -# define VINT8x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT8x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 16, 8) -# define VINT8x16_LOAD_DEFINED -#endif - -#ifndef VINT8x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 16, 8) -# define VINT8x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT8x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 8, 16, 8) -# define VINT8x16_STORE_DEFINED -#endif - -#ifndef VINT8x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 8, 16, 8) -# define VINT8x16_ADD_DEFINED -#endif - -#ifndef VINT8x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 8, 16, 8) -# define VINT8x16_SUB_DEFINED -#endif - -#ifndef VINT8x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 8, 16, 8) -# define VINT8x16_MUL_DEFINED -#endif - -#ifndef VINT8x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 8, 16, 8) -# define VINT8x16_DIV_DEFINED -#endif - -#ifndef VINT8x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 8, 16, 8) -# define VINT8x16_MOD_DEFINED -#endif - -#ifndef VINT8x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 8, 16, 8) -# define VINT8x16_AVG_DEFINED -#endif - -#ifndef VINT8x16_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 8, 16, 8) -# define VINT8x16_AND_DEFINED -#endif - -#ifndef VINT8x16_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 8, 16, 8) -# define VINT8x16_OR_DEFINED -#endif - -#ifndef VINT8x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 8, 16, 8) -# define VINT8x16_XOR_DEFINED -#endif - -#ifndef VINT8x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 8, 16, 8) -# define VINT8x16_NOT_DEFINED -#endif - -#ifndef VINT8x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 16, 8) -# define VINT8x16_CMPLT_DEFINED -#endif - -#ifndef VINT8x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 16, 8) -# define VINT8x16_CMPEQ_DEFINED -#endif - -#ifndef VINT8x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 16, 8) -# define VINT8x16_CMPGT_DEFINED -#endif - -#ifndef VINT8x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 16, 8) -# define VINT8x16_CMPLE_DEFINED -#endif - -#ifndef VINT8x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 16, 8) -# define VINT8x16_CMPGE_DEFINED -#endif - -#ifndef VINT8x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 8, 16, 8) -# define VINT8x16_MIN_DEFINED -#endif - -#ifndef VINT8x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 8, 16, 8) -# define VINT8x16_MAX_DEFINED -#endif - -#ifndef VINT8x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 16, 8) -# define VINT8x16_RSHIFT_DEFINED -#endif - -#ifndef VINT8x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 16, 8) -# define VINT8x16_LRSHIFT_DEFINED -#endif - -#ifndef VINT8x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 16, 8) -# define VINT8x16_LSHIFT_DEFINED -#endif - - - -/* vint8x16 */ - -#ifndef VUINT8x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 8, 16, 8) -# define VUINT8x16_SPLAT_DEFINED -#endif - -#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 16, 8) -# define VUINT8x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 8, 16, 8) -# define VUINT8x16_LOAD_DEFINED -#endif - -#ifndef VUINT8x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 16, 8) -# define VUINT8x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 8, 16, 8) -# define VUINT8x16_STORE_DEFINED -#endif - -#ifndef VUINT8x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 8, 16, 8) -# define VUINT8x16_ADD_DEFINED -#endif - -#ifndef VUINT8x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 8, 16, 8) -# define VUINT8x16_SUB_DEFINED -#endif - -#ifndef VUINT8x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 8, 16, 8) -# define VUINT8x16_MUL_DEFINED -#endif - -#ifndef VUINT8x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 8, 16, 8) -# define VUINT8x16_DIV_DEFINED -#endif - -#ifndef VUINT8x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 8, 16, 8) -# define VUINT8x16_MOD_DEFINED -#endif - -#ifndef VUINT8x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 8, 16, 8) -# define VUINT8x16_AVG_DEFINED -#endif - -#ifndef VUINT8x16_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 8, 16, 8) -# define VUINT8x16_AND_DEFINED -#endif - -#ifndef VUINT8x16_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 8, 16, 8) -# define VUINT8x16_OR_DEFINED -#endif - -#ifndef VUINT8x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 8, 16, 8) -# define VUINT8x16_XOR_DEFINED -#endif - -#ifndef VUINT8x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 8, 16, 8) -# define VUINT8x16_NOT_DEFINED -#endif - -#ifndef VUINT8x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 8, 16, 8) -# define VUINT8x16_CMPLT_DEFINED -#endif - -#ifndef VUINT8x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 8, 16, 8) -# define VUINT8x16_CMPEQ_DEFINED -#endif - -#ifndef VUINT8x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 8, 16, 8) -# define VUINT8x16_CMPGT_DEFINED -#endif - -#ifndef VUINT8x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 8, 16, 8) -# define VUINT8x16_CMPLE_DEFINED -#endif - -#ifndef VUINT8x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 8, 16, 8) -# define VUINT8x16_CMPGE_DEFINED -#endif - -#ifndef VUINT8x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 8, 16, 8) -# define VUINT8x16_MIN_DEFINED -#endif - -#ifndef VUINT8x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 8, 16, 8) -# define VUINT8x16_MAX_DEFINED -#endif - -#ifndef VUINT8x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 8, 16, 8) -# define VUINT8x16_RSHIFT_DEFINED -#endif - -#ifndef VUINT8x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 8, 16, 8) -# define VUINT8x16_LRSHIFT_DEFINED -#endif - -#ifndef VUINT8x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 8, 16, 8) -# define VUINT8x16_LSHIFT_DEFINED -#endif - - - -/* vuint8x32 */ - -#ifndef VINT8x32_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 32, 16) -# define VINT8x32_SPLAT_DEFINED -#endif - -#ifndef VINT8x32_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 32, 16) -# define VINT8x32_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT8x32_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 32, 16) -# define VINT8x32_LOAD_DEFINED -#endif - -#ifndef VINT8x32_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 32, 16) -# define VINT8x32_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT8x32_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 8, 32, 16) -# define VINT8x32_STORE_DEFINED -#endif - -#ifndef VINT8x32_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 8, 32, 16) -# define VINT8x32_ADD_DEFINED -#endif - -#ifndef VINT8x32_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 8, 32, 16) -# define VINT8x32_SUB_DEFINED -#endif - -#ifndef VINT8x32_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 8, 32, 16) -# define VINT8x32_MUL_DEFINED -#endif - -#ifndef VINT8x32_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 8, 32, 16) -# define VINT8x32_DIV_DEFINED -#endif - -#ifndef VINT8x32_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 8, 32, 16) -# define VINT8x32_MOD_DEFINED -#endif - -#ifndef VINT8x32_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 8, 32, 16) -# define VINT8x32_AVG_DEFINED -#endif - -#ifndef VINT8x32_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 8, 32, 16) -# define VINT8x32_AND_DEFINED -#endif - -#ifndef VINT8x32_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 8, 32, 16) -# define VINT8x32_OR_DEFINED -#endif - -#ifndef VINT8x32_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 8, 32, 16) -# define VINT8x32_XOR_DEFINED -#endif - -#ifndef VINT8x32_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 8, 32, 16) -# define VINT8x32_NOT_DEFINED -#endif - -#ifndef VINT8x32_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 32, 16) -# define VINT8x32_CMPLT_DEFINED -#endif - -#ifndef VINT8x32_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 32, 16) -# define VINT8x32_CMPEQ_DEFINED -#endif - -#ifndef VINT8x32_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 32, 16) -# define VINT8x32_CMPGT_DEFINED -#endif - -#ifndef VINT8x32_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 32, 16) -# define VINT8x32_CMPLE_DEFINED -#endif - -#ifndef VINT8x32_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 32, 16) -# define VINT8x32_CMPGE_DEFINED -#endif - -#ifndef VINT8x32_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 8, 32, 16) -# define VINT8x32_MIN_DEFINED -#endif - -#ifndef VINT8x32_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 8, 32, 16) -# define VINT8x32_MAX_DEFINED -#endif - -#ifndef VINT8x32_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 32, 16) -# define VINT8x32_RSHIFT_DEFINED -#endif - -#ifndef VINT8x32_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 32, 16) -# define VINT8x32_LRSHIFT_DEFINED -#endif - -#ifndef VINT8x32_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 32, 16) -# define VINT8x32_LSHIFT_DEFINED -#endif - - - -/* vint8x32 */ - -#ifndef VUINT8x32_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 8, 32, 16) -# define VUINT8x32_SPLAT_DEFINED -#endif - -#ifndef VUINT8x32_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 32, 16) -# define VUINT8x32_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x32_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 8, 32, 16) -# define VUINT8x32_LOAD_DEFINED -#endif - -#ifndef VUINT8x32_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 32, 16) -# define VUINT8x32_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x32_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 8, 32, 16) -# define VUINT8x32_STORE_DEFINED -#endif - -#ifndef VUINT8x32_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 8, 32, 16) -# define VUINT8x32_ADD_DEFINED -#endif - -#ifndef VUINT8x32_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 8, 32, 16) -# define VUINT8x32_SUB_DEFINED -#endif - -#ifndef VUINT8x32_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 8, 32, 16) -# define VUINT8x32_MUL_DEFINED -#endif - -#ifndef VUINT8x32_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 8, 32, 16) -# define VUINT8x32_DIV_DEFINED -#endif - -#ifndef VUINT8x32_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 8, 32, 16) -# define VUINT8x32_MOD_DEFINED -#endif - -#ifndef VUINT8x32_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 8, 32, 16) -# define VUINT8x32_AVG_DEFINED -#endif - -#ifndef VUINT8x32_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 8, 32, 16) -# define VUINT8x32_AND_DEFINED -#endif - -#ifndef VUINT8x32_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 8, 32, 16) -# define VUINT8x32_OR_DEFINED -#endif - -#ifndef VUINT8x32_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 8, 32, 16) -# define VUINT8x32_XOR_DEFINED -#endif - -#ifndef VUINT8x32_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 8, 32, 16) -# define VUINT8x32_NOT_DEFINED -#endif - -#ifndef VUINT8x32_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 8, 32, 16) -# define VUINT8x32_CMPLT_DEFINED -#endif - -#ifndef VUINT8x32_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 8, 32, 16) -# define VUINT8x32_CMPEQ_DEFINED -#endif - -#ifndef VUINT8x32_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 8, 32, 16) -# define VUINT8x32_CMPGT_DEFINED -#endif - -#ifndef VUINT8x32_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 8, 32, 16) -# define VUINT8x32_CMPLE_DEFINED -#endif - -#ifndef VUINT8x32_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 8, 32, 16) -# define VUINT8x32_CMPGE_DEFINED -#endif - -#ifndef VUINT8x32_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 8, 32, 16) -# define VUINT8x32_MIN_DEFINED -#endif - -#ifndef VUINT8x32_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 8, 32, 16) -# define VUINT8x32_MAX_DEFINED -#endif - -#ifndef VUINT8x32_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 8, 32, 16) -# define VUINT8x32_RSHIFT_DEFINED -#endif - -#ifndef VUINT8x32_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 8, 32, 16) -# define VUINT8x32_LRSHIFT_DEFINED -#endif - -#ifndef VUINT8x32_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 8, 32, 16) -# define VUINT8x32_LSHIFT_DEFINED -#endif - - - -/* vuint8x64 */ - -#ifndef VINT8x64_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 64, 32) -# define VINT8x64_SPLAT_DEFINED -#endif - -#ifndef VINT8x64_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 64, 32) -# define VINT8x64_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT8x64_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 64, 32) -# define VINT8x64_LOAD_DEFINED -#endif - -#ifndef VINT8x64_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 64, 32) -# define VINT8x64_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT8x64_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 8, 64, 32) -# define VINT8x64_STORE_DEFINED -#endif - -#ifndef VINT8x64_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 8, 64, 32) -# define VINT8x64_ADD_DEFINED -#endif - -#ifndef VINT8x64_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 8, 64, 32) -# define VINT8x64_SUB_DEFINED -#endif - -#ifndef VINT8x64_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 8, 64, 32) -# define VINT8x64_MUL_DEFINED -#endif - -#ifndef VINT8x64_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 8, 64, 32) -# define VINT8x64_DIV_DEFINED -#endif - -#ifndef VINT8x64_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 8, 64, 32) -# define VINT8x64_MOD_DEFINED -#endif - -#ifndef VINT8x64_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 8, 64, 32) -# define VINT8x64_AVG_DEFINED -#endif - -#ifndef VINT8x64_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 8, 64, 32) -# define VINT8x64_AND_DEFINED -#endif - -#ifndef VINT8x64_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 8, 64, 32) -# define VINT8x64_OR_DEFINED -#endif - -#ifndef VINT8x64_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 8, 64, 32) -# define VINT8x64_XOR_DEFINED -#endif - -#ifndef VINT8x64_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 8, 64, 32) -# define VINT8x64_NOT_DEFINED -#endif - -#ifndef VINT8x64_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 64, 32) -# define VINT8x64_CMPLT_DEFINED -#endif - -#ifndef VINT8x64_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 64, 32) -# define VINT8x64_CMPEQ_DEFINED -#endif - -#ifndef VINT8x64_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 64, 32) -# define VINT8x64_CMPGT_DEFINED -#endif - -#ifndef VINT8x64_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 64, 32) -# define VINT8x64_CMPLE_DEFINED -#endif - -#ifndef VINT8x64_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 64, 32) -# define VINT8x64_CMPGE_DEFINED -#endif - -#ifndef VINT8x64_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 8, 64, 32) -# define VINT8x64_MIN_DEFINED -#endif - -#ifndef VINT8x64_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 8, 64, 32) -# define VINT8x64_MAX_DEFINED -#endif - -#ifndef VINT8x64_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 64, 32) -# define VINT8x64_RSHIFT_DEFINED -#endif - -#ifndef VINT8x64_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 64, 32) -# define VINT8x64_LRSHIFT_DEFINED -#endif - -#ifndef VINT8x64_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 64, 32) -# define VINT8x64_LSHIFT_DEFINED -#endif - - - -/* vint8x64 */ - -#ifndef VUINT8x64_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 8, 64, 32) -# define VUINT8x64_SPLAT_DEFINED -#endif - -#ifndef VUINT8x64_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 64, 32) -# define VUINT8x64_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x64_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 8, 64, 32) -# define VUINT8x64_LOAD_DEFINED -#endif - -#ifndef VUINT8x64_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 64, 32) -# define VUINT8x64_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT8x64_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 8, 64, 32) -# define VUINT8x64_STORE_DEFINED -#endif - -#ifndef VUINT8x64_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 8, 64, 32) -# define VUINT8x64_ADD_DEFINED -#endif - -#ifndef VUINT8x64_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 8, 64, 32) -# define VUINT8x64_SUB_DEFINED -#endif - -#ifndef VUINT8x64_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 8, 64, 32) -# define VUINT8x64_MUL_DEFINED -#endif - -#ifndef VUINT8x64_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 8, 64, 32) -# define VUINT8x64_DIV_DEFINED -#endif - -#ifndef VUINT8x64_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 8, 64, 32) -# define VUINT8x64_MOD_DEFINED -#endif - -#ifndef VUINT8x64_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 8, 64, 32) -# define VUINT8x64_AVG_DEFINED -#endif - -#ifndef VUINT8x64_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 8, 64, 32) -# define VUINT8x64_AND_DEFINED -#endif - -#ifndef VUINT8x64_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 8, 64, 32) -# define VUINT8x64_OR_DEFINED -#endif - -#ifndef VUINT8x64_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 8, 64, 32) -# define VUINT8x64_XOR_DEFINED -#endif - -#ifndef VUINT8x64_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 8, 64, 32) -# define VUINT8x64_NOT_DEFINED -#endif - -#ifndef VUINT8x64_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 8, 64, 32) -# define VUINT8x64_CMPLT_DEFINED -#endif - -#ifndef VUINT8x64_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 8, 64, 32) -# define VUINT8x64_CMPEQ_DEFINED -#endif - -#ifndef VUINT8x64_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 8, 64, 32) -# define VUINT8x64_CMPGT_DEFINED -#endif - -#ifndef VUINT8x64_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 8, 64, 32) -# define VUINT8x64_CMPLE_DEFINED -#endif - -#ifndef VUINT8x64_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 8, 64, 32) -# define VUINT8x64_CMPGE_DEFINED -#endif - -#ifndef VUINT8x64_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 8, 64, 32) -# define VUINT8x64_MIN_DEFINED -#endif - -#ifndef VUINT8x64_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 8, 64, 32) -# define VUINT8x64_MAX_DEFINED -#endif - -#ifndef VUINT8x64_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 8, 64, 32) -# define VUINT8x64_RSHIFT_DEFINED -#endif - -#ifndef VUINT8x64_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 8, 64, 32) -# define VUINT8x64_LRSHIFT_DEFINED -#endif - -#ifndef VUINT8x64_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 8, 64, 32) -# define VUINT8x64_LSHIFT_DEFINED -#endif - - - /* vuint16x2 */ #ifndef VINT16x2_SPLAT_DEFINED @@ -1992,1038 +629,6 @@ #endif -/* vuint16x4 */ - -#ifndef VINT16x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 4, 2) -# define VINT16x4_SPLAT_DEFINED -#endif - -#ifndef VINT16x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 4, 2) -# define VINT16x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT16x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 4, 2) -# define VINT16x4_LOAD_DEFINED -#endif - -#ifndef VINT16x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 4, 2) -# define VINT16x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT16x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 16, 4, 2) -# define VINT16x4_STORE_DEFINED -#endif - -#ifndef VINT16x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 16, 4, 2) -# define VINT16x4_ADD_DEFINED -#endif - -#ifndef VINT16x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 16, 4, 2) -# define VINT16x4_SUB_DEFINED -#endif - -#ifndef VINT16x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 16, 4, 2) -# define VINT16x4_MUL_DEFINED -#endif - -#ifndef VINT16x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 16, 4, 2) -# define VINT16x4_DIV_DEFINED -#endif - -#ifndef VINT16x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 16, 4, 2) -# define VINT16x4_MOD_DEFINED -#endif - -#ifndef VINT16x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 16, 4, 2) -# define VINT16x4_AVG_DEFINED -#endif - -#ifndef VINT16x4_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 16, 4, 2) -# define VINT16x4_AND_DEFINED -#endif - -#ifndef VINT16x4_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 16, 4, 2) -# define VINT16x4_OR_DEFINED -#endif - -#ifndef VINT16x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 16, 4, 2) -# define VINT16x4_XOR_DEFINED -#endif - -#ifndef VINT16x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 16, 4, 2) -# define VINT16x4_NOT_DEFINED -#endif - -#ifndef VINT16x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 4, 2) -# define VINT16x4_CMPLT_DEFINED -#endif - -#ifndef VINT16x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 4, 2) -# define VINT16x4_CMPEQ_DEFINED -#endif - -#ifndef VINT16x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 4, 2) -# define VINT16x4_CMPGT_DEFINED -#endif - -#ifndef VINT16x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 4, 2) -# define VINT16x4_CMPLE_DEFINED -#endif - -#ifndef VINT16x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 4, 2) -# define VINT16x4_CMPGE_DEFINED -#endif - -#ifndef VINT16x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 16, 4, 2) -# define VINT16x4_MIN_DEFINED -#endif - -#ifndef VINT16x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 16, 4, 2) -# define VINT16x4_MAX_DEFINED -#endif - -#ifndef VINT16x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 4, 2) -# define VINT16x4_RSHIFT_DEFINED -#endif - -#ifndef VINT16x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 4, 2) -# define VINT16x4_LRSHIFT_DEFINED -#endif - -#ifndef VINT16x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 4, 2) -# define VINT16x4_LSHIFT_DEFINED -#endif - - - -/* vint16x4 */ - -#ifndef VUINT16x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 16, 4, 2) -# define VUINT16x4_SPLAT_DEFINED -#endif - -#ifndef VUINT16x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 4, 2) -# define VUINT16x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 16, 4, 2) -# define VUINT16x4_LOAD_DEFINED -#endif - -#ifndef VUINT16x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 4, 2) -# define VUINT16x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 16, 4, 2) -# define VUINT16x4_STORE_DEFINED -#endif - -#ifndef VUINT16x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 16, 4, 2) -# define VUINT16x4_ADD_DEFINED -#endif - -#ifndef VUINT16x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 16, 4, 2) -# define VUINT16x4_SUB_DEFINED -#endif - -#ifndef VUINT16x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 16, 4, 2) -# define VUINT16x4_MUL_DEFINED -#endif - -#ifndef VUINT16x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 16, 4, 2) -# define VUINT16x4_DIV_DEFINED -#endif - -#ifndef VUINT16x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 16, 4, 2) -# define VUINT16x4_MOD_DEFINED -#endif - -#ifndef VUINT16x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 16, 4, 2) -# define VUINT16x4_AVG_DEFINED -#endif - -#ifndef VUINT16x4_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 16, 4, 2) -# define VUINT16x4_AND_DEFINED -#endif - -#ifndef VUINT16x4_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 16, 4, 2) -# define VUINT16x4_OR_DEFINED -#endif - -#ifndef VUINT16x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 16, 4, 2) -# define VUINT16x4_XOR_DEFINED -#endif - -#ifndef VUINT16x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 16, 4, 2) -# define VUINT16x4_NOT_DEFINED -#endif - -#ifndef VUINT16x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 16, 4, 2) -# define VUINT16x4_CMPLT_DEFINED -#endif - -#ifndef VUINT16x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 16, 4, 2) -# define VUINT16x4_CMPEQ_DEFINED -#endif - -#ifndef VUINT16x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 16, 4, 2) -# define VUINT16x4_CMPGT_DEFINED -#endif - -#ifndef VUINT16x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 16, 4, 2) -# define VUINT16x4_CMPLE_DEFINED -#endif - -#ifndef VUINT16x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 16, 4, 2) -# define VUINT16x4_CMPGE_DEFINED -#endif - -#ifndef VUINT16x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 16, 4, 2) -# define VUINT16x4_MIN_DEFINED -#endif - -#ifndef VUINT16x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 16, 4, 2) -# define VUINT16x4_MAX_DEFINED -#endif - -#ifndef VUINT16x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 16, 4, 2) -# define VUINT16x4_RSHIFT_DEFINED -#endif - -#ifndef VUINT16x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 16, 4, 2) -# define VUINT16x4_LRSHIFT_DEFINED -#endif - -#ifndef VUINT16x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 16, 4, 2) -# define VUINT16x4_LSHIFT_DEFINED -#endif - - - -/* vuint16x8 */ - -#ifndef VINT16x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 8, 4) -# define VINT16x8_SPLAT_DEFINED -#endif - -#ifndef VINT16x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 8, 4) -# define VINT16x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT16x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 8, 4) -# define VINT16x8_LOAD_DEFINED -#endif - -#ifndef VINT16x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 8, 4) -# define VINT16x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT16x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 16, 8, 4) -# define VINT16x8_STORE_DEFINED -#endif - -#ifndef VINT16x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 16, 8, 4) -# define VINT16x8_ADD_DEFINED -#endif - -#ifndef VINT16x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 16, 8, 4) -# define VINT16x8_SUB_DEFINED -#endif - -#ifndef VINT16x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 16, 8, 4) -# define VINT16x8_MUL_DEFINED -#endif - -#ifndef VINT16x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 16, 8, 4) -# define VINT16x8_DIV_DEFINED -#endif - -#ifndef VINT16x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 16, 8, 4) -# define VINT16x8_MOD_DEFINED -#endif - -#ifndef VINT16x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 16, 8, 4) -# define VINT16x8_AVG_DEFINED -#endif - -#ifndef VINT16x8_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 16, 8, 4) -# define VINT16x8_AND_DEFINED -#endif - -#ifndef VINT16x8_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 16, 8, 4) -# define VINT16x8_OR_DEFINED -#endif - -#ifndef VINT16x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 16, 8, 4) -# define VINT16x8_XOR_DEFINED -#endif - -#ifndef VINT16x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 16, 8, 4) -# define VINT16x8_NOT_DEFINED -#endif - -#ifndef VINT16x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 8, 4) -# define VINT16x8_CMPLT_DEFINED -#endif - -#ifndef VINT16x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 8, 4) -# define VINT16x8_CMPEQ_DEFINED -#endif - -#ifndef VINT16x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 8, 4) -# define VINT16x8_CMPGT_DEFINED -#endif - -#ifndef VINT16x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 8, 4) -# define VINT16x8_CMPLE_DEFINED -#endif - -#ifndef VINT16x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 8, 4) -# define VINT16x8_CMPGE_DEFINED -#endif - -#ifndef VINT16x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 16, 8, 4) -# define VINT16x8_MIN_DEFINED -#endif - -#ifndef VINT16x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 16, 8, 4) -# define VINT16x8_MAX_DEFINED -#endif - -#ifndef VINT16x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 8, 4) -# define VINT16x8_RSHIFT_DEFINED -#endif - -#ifndef VINT16x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 8, 4) -# define VINT16x8_LRSHIFT_DEFINED -#endif - -#ifndef VINT16x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 8, 4) -# define VINT16x8_LSHIFT_DEFINED -#endif - - - -/* vint16x8 */ - -#ifndef VUINT16x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 16, 8, 4) -# define VUINT16x8_SPLAT_DEFINED -#endif - -#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 8, 4) -# define VUINT16x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 16, 8, 4) -# define VUINT16x8_LOAD_DEFINED -#endif - -#ifndef VUINT16x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 8, 4) -# define VUINT16x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 16, 8, 4) -# define VUINT16x8_STORE_DEFINED -#endif - -#ifndef VUINT16x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 16, 8, 4) -# define VUINT16x8_ADD_DEFINED -#endif - -#ifndef VUINT16x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 16, 8, 4) -# define VUINT16x8_SUB_DEFINED -#endif - -#ifndef VUINT16x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 16, 8, 4) -# define VUINT16x8_MUL_DEFINED -#endif - -#ifndef VUINT16x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 16, 8, 4) -# define VUINT16x8_DIV_DEFINED -#endif - -#ifndef VUINT16x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 16, 8, 4) -# define VUINT16x8_MOD_DEFINED -#endif - -#ifndef VUINT16x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 16, 8, 4) -# define VUINT16x8_AVG_DEFINED -#endif - -#ifndef VUINT16x8_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 16, 8, 4) -# define VUINT16x8_AND_DEFINED -#endif - -#ifndef VUINT16x8_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 16, 8, 4) -# define VUINT16x8_OR_DEFINED -#endif - -#ifndef VUINT16x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 16, 8, 4) -# define VUINT16x8_XOR_DEFINED -#endif - -#ifndef VUINT16x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 16, 8, 4) -# define VUINT16x8_NOT_DEFINED -#endif - -#ifndef VUINT16x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 16, 8, 4) -# define VUINT16x8_CMPLT_DEFINED -#endif - -#ifndef VUINT16x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 16, 8, 4) -# define VUINT16x8_CMPEQ_DEFINED -#endif - -#ifndef VUINT16x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 16, 8, 4) -# define VUINT16x8_CMPGT_DEFINED -#endif - -#ifndef VUINT16x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 16, 8, 4) -# define VUINT16x8_CMPLE_DEFINED -#endif - -#ifndef VUINT16x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 16, 8, 4) -# define VUINT16x8_CMPGE_DEFINED -#endif - -#ifndef VUINT16x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 16, 8, 4) -# define VUINT16x8_MIN_DEFINED -#endif - -#ifndef VUINT16x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 16, 8, 4) -# define VUINT16x8_MAX_DEFINED -#endif - -#ifndef VUINT16x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 16, 8, 4) -# define VUINT16x8_RSHIFT_DEFINED -#endif - -#ifndef VUINT16x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 16, 8, 4) -# define VUINT16x8_LRSHIFT_DEFINED -#endif - -#ifndef VUINT16x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 16, 8, 4) -# define VUINT16x8_LSHIFT_DEFINED -#endif - - - -/* vuint16x16 */ - -#ifndef VINT16x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 16, 8) -# define VINT16x16_SPLAT_DEFINED -#endif - -#ifndef VINT16x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 16, 8) -# define VINT16x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT16x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 16, 8) -# define VINT16x16_LOAD_DEFINED -#endif - -#ifndef VINT16x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 16, 8) -# define VINT16x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT16x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 16, 16, 8) -# define VINT16x16_STORE_DEFINED -#endif - -#ifndef VINT16x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 16, 16, 8) -# define VINT16x16_ADD_DEFINED -#endif - -#ifndef VINT16x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 16, 16, 8) -# define VINT16x16_SUB_DEFINED -#endif - -#ifndef VINT16x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 16, 16, 8) -# define VINT16x16_MUL_DEFINED -#endif - -#ifndef VINT16x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 16, 16, 8) -# define VINT16x16_DIV_DEFINED -#endif - -#ifndef VINT16x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 16, 16, 8) -# define VINT16x16_MOD_DEFINED -#endif - -#ifndef VINT16x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 16, 16, 8) -# define VINT16x16_AVG_DEFINED -#endif - -#ifndef VINT16x16_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 16, 16, 8) -# define VINT16x16_AND_DEFINED -#endif - -#ifndef VINT16x16_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 16, 16, 8) -# define VINT16x16_OR_DEFINED -#endif - -#ifndef VINT16x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 16, 16, 8) -# define VINT16x16_XOR_DEFINED -#endif - -#ifndef VINT16x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 16, 16, 8) -# define VINT16x16_NOT_DEFINED -#endif - -#ifndef VINT16x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 16, 8) -# define VINT16x16_CMPLT_DEFINED -#endif - -#ifndef VINT16x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 16, 8) -# define VINT16x16_CMPEQ_DEFINED -#endif - -#ifndef VINT16x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 16, 8) -# define VINT16x16_CMPGT_DEFINED -#endif - -#ifndef VINT16x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 16, 8) -# define VINT16x16_CMPLE_DEFINED -#endif - -#ifndef VINT16x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 16, 8) -# define VINT16x16_CMPGE_DEFINED -#endif - -#ifndef VINT16x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 16, 16, 8) -# define VINT16x16_MIN_DEFINED -#endif - -#ifndef VINT16x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 16, 16, 8) -# define VINT16x16_MAX_DEFINED -#endif - -#ifndef VINT16x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 16, 8) -# define VINT16x16_RSHIFT_DEFINED -#endif - -#ifndef VINT16x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 16, 8) -# define VINT16x16_LRSHIFT_DEFINED -#endif - -#ifndef VINT16x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 16, 8) -# define VINT16x16_LSHIFT_DEFINED -#endif - - - -/* vint16x16 */ - -#ifndef VUINT16x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 16, 16, 8) -# define VUINT16x16_SPLAT_DEFINED -#endif - -#ifndef VUINT16x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 16, 8) -# define VUINT16x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 16, 16, 8) -# define VUINT16x16_LOAD_DEFINED -#endif - -#ifndef VUINT16x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 16, 8) -# define VUINT16x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 16, 16, 8) -# define VUINT16x16_STORE_DEFINED -#endif - -#ifndef VUINT16x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 16, 16, 8) -# define VUINT16x16_ADD_DEFINED -#endif - -#ifndef VUINT16x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 16, 16, 8) -# define VUINT16x16_SUB_DEFINED -#endif - -#ifndef VUINT16x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 16, 16, 8) -# define VUINT16x16_MUL_DEFINED -#endif - -#ifndef VUINT16x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 16, 16, 8) -# define VUINT16x16_DIV_DEFINED -#endif - -#ifndef VUINT16x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 16, 16, 8) -# define VUINT16x16_MOD_DEFINED -#endif - -#ifndef VUINT16x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 16, 16, 8) -# define VUINT16x16_AVG_DEFINED -#endif - -#ifndef VUINT16x16_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 16, 16, 8) -# define VUINT16x16_AND_DEFINED -#endif - -#ifndef VUINT16x16_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 16, 16, 8) -# define VUINT16x16_OR_DEFINED -#endif - -#ifndef VUINT16x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 16, 16, 8) -# define VUINT16x16_XOR_DEFINED -#endif - -#ifndef VUINT16x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 16, 16, 8) -# define VUINT16x16_NOT_DEFINED -#endif - -#ifndef VUINT16x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 16, 16, 8) -# define VUINT16x16_CMPLT_DEFINED -#endif - -#ifndef VUINT16x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 16, 16, 8) -# define VUINT16x16_CMPEQ_DEFINED -#endif - -#ifndef VUINT16x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 16, 16, 8) -# define VUINT16x16_CMPGT_DEFINED -#endif - -#ifndef VUINT16x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 16, 16, 8) -# define VUINT16x16_CMPLE_DEFINED -#endif - -#ifndef VUINT16x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 16, 16, 8) -# define VUINT16x16_CMPGE_DEFINED -#endif - -#ifndef VUINT16x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 16, 16, 8) -# define VUINT16x16_MIN_DEFINED -#endif - -#ifndef VUINT16x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 16, 16, 8) -# define VUINT16x16_MAX_DEFINED -#endif - -#ifndef VUINT16x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 16, 16, 8) -# define VUINT16x16_RSHIFT_DEFINED -#endif - -#ifndef VUINT16x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 16, 16, 8) -# define VUINT16x16_LRSHIFT_DEFINED -#endif - -#ifndef VUINT16x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 16, 16, 8) -# define VUINT16x16_LSHIFT_DEFINED -#endif - - - -/* vuint16x32 */ - -#ifndef VINT16x32_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 32, 16) -# define VINT16x32_SPLAT_DEFINED -#endif - -#ifndef VINT16x32_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 32, 16) -# define VINT16x32_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT16x32_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 32, 16) -# define VINT16x32_LOAD_DEFINED -#endif - -#ifndef VINT16x32_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 32, 16) -# define VINT16x32_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT16x32_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 16, 32, 16) -# define VINT16x32_STORE_DEFINED -#endif - -#ifndef VINT16x32_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 16, 32, 16) -# define VINT16x32_ADD_DEFINED -#endif - -#ifndef VINT16x32_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 16, 32, 16) -# define VINT16x32_SUB_DEFINED -#endif - -#ifndef VINT16x32_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 16, 32, 16) -# define VINT16x32_MUL_DEFINED -#endif - -#ifndef VINT16x32_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 16, 32, 16) -# define VINT16x32_DIV_DEFINED -#endif - -#ifndef VINT16x32_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 16, 32, 16) -# define VINT16x32_MOD_DEFINED -#endif - -#ifndef VINT16x32_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 16, 32, 16) -# define VINT16x32_AVG_DEFINED -#endif - -#ifndef VINT16x32_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 16, 32, 16) -# define VINT16x32_AND_DEFINED -#endif - -#ifndef VINT16x32_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 16, 32, 16) -# define VINT16x32_OR_DEFINED -#endif - -#ifndef VINT16x32_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 16, 32, 16) -# define VINT16x32_XOR_DEFINED -#endif - -#ifndef VINT16x32_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 16, 32, 16) -# define VINT16x32_NOT_DEFINED -#endif - -#ifndef VINT16x32_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 32, 16) -# define VINT16x32_CMPLT_DEFINED -#endif - -#ifndef VINT16x32_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 32, 16) -# define VINT16x32_CMPEQ_DEFINED -#endif - -#ifndef VINT16x32_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 32, 16) -# define VINT16x32_CMPGT_DEFINED -#endif - -#ifndef VINT16x32_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 32, 16) -# define VINT16x32_CMPLE_DEFINED -#endif - -#ifndef VINT16x32_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 32, 16) -# define VINT16x32_CMPGE_DEFINED -#endif - -#ifndef VINT16x32_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 16, 32, 16) -# define VINT16x32_MIN_DEFINED -#endif - -#ifndef VINT16x32_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 16, 32, 16) -# define VINT16x32_MAX_DEFINED -#endif - -#ifndef VINT16x32_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 32, 16) -# define VINT16x32_RSHIFT_DEFINED -#endif - -#ifndef VINT16x32_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 32, 16) -# define VINT16x32_LRSHIFT_DEFINED -#endif - -#ifndef VINT16x32_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 32, 16) -# define VINT16x32_LSHIFT_DEFINED -#endif - - - -/* vint16x32 */ - -#ifndef VUINT16x32_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 16, 32, 16) -# define VUINT16x32_SPLAT_DEFINED -#endif - -#ifndef VUINT16x32_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 32, 16) -# define VUINT16x32_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x32_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 16, 32, 16) -# define VUINT16x32_LOAD_DEFINED -#endif - -#ifndef VUINT16x32_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 32, 16) -# define VUINT16x32_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT16x32_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 16, 32, 16) -# define VUINT16x32_STORE_DEFINED -#endif - -#ifndef VUINT16x32_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 16, 32, 16) -# define VUINT16x32_ADD_DEFINED -#endif - -#ifndef VUINT16x32_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 16, 32, 16) -# define VUINT16x32_SUB_DEFINED -#endif - -#ifndef VUINT16x32_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 16, 32, 16) -# define VUINT16x32_MUL_DEFINED -#endif - -#ifndef VUINT16x32_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 16, 32, 16) -# define VUINT16x32_DIV_DEFINED -#endif - -#ifndef VUINT16x32_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 16, 32, 16) -# define VUINT16x32_MOD_DEFINED -#endif - -#ifndef VUINT16x32_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 16, 32, 16) -# define VUINT16x32_AVG_DEFINED -#endif - -#ifndef VUINT16x32_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 16, 32, 16) -# define VUINT16x32_AND_DEFINED -#endif - -#ifndef VUINT16x32_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 16, 32, 16) -# define VUINT16x32_OR_DEFINED -#endif - -#ifndef VUINT16x32_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 16, 32, 16) -# define VUINT16x32_XOR_DEFINED -#endif - -#ifndef VUINT16x32_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 16, 32, 16) -# define VUINT16x32_NOT_DEFINED -#endif - -#ifndef VUINT16x32_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 16, 32, 16) -# define VUINT16x32_CMPLT_DEFINED -#endif - -#ifndef VUINT16x32_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 16, 32, 16) -# define VUINT16x32_CMPEQ_DEFINED -#endif - -#ifndef VUINT16x32_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 16, 32, 16) -# define VUINT16x32_CMPGT_DEFINED -#endif - -#ifndef VUINT16x32_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 16, 32, 16) -# define VUINT16x32_CMPLE_DEFINED -#endif - -#ifndef VUINT16x32_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 16, 32, 16) -# define VUINT16x32_CMPGE_DEFINED -#endif - -#ifndef VUINT16x32_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 16, 32, 16) -# define VUINT16x32_MIN_DEFINED -#endif - -#ifndef VUINT16x32_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 16, 32, 16) -# define VUINT16x32_MAX_DEFINED -#endif - -#ifndef VUINT16x32_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 16, 32, 16) -# define VUINT16x32_RSHIFT_DEFINED -#endif - -#ifndef VUINT16x32_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 16, 32, 16) -# define VUINT16x32_LRSHIFT_DEFINED -#endif - -#ifndef VUINT16x32_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 16, 32, 16) -# define VUINT16x32_LSHIFT_DEFINED -#endif - - - /* vuint32x2 */ #ifndef VINT32x2_SPLAT_DEFINED @@ -3232,780 +837,6 @@ #endif -/* vuint32x4 */ - -#ifndef VINT32x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 4, 2) -# define VINT32x4_SPLAT_DEFINED -#endif - -#ifndef VINT32x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 4, 2) -# define VINT32x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT32x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 4, 2) -# define VINT32x4_LOAD_DEFINED -#endif - -#ifndef VINT32x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 4, 2) -# define VINT32x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT32x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 32, 4, 2) -# define VINT32x4_STORE_DEFINED -#endif - -#ifndef VINT32x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 32, 4, 2) -# define VINT32x4_ADD_DEFINED -#endif - -#ifndef VINT32x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 32, 4, 2) -# define VINT32x4_SUB_DEFINED -#endif - -#ifndef VINT32x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 32, 4, 2) -# define VINT32x4_MUL_DEFINED -#endif - -#ifndef VINT32x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 32, 4, 2) -# define VINT32x4_DIV_DEFINED -#endif - -#ifndef VINT32x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 32, 4, 2) -# define VINT32x4_MOD_DEFINED -#endif - -#ifndef VINT32x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 32, 4, 2) -# define VINT32x4_AVG_DEFINED -#endif - -#ifndef VINT32x4_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 32, 4, 2) -# define VINT32x4_AND_DEFINED -#endif - -#ifndef VINT32x4_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 32, 4, 2) -# define VINT32x4_OR_DEFINED -#endif - -#ifndef VINT32x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 32, 4, 2) -# define VINT32x4_XOR_DEFINED -#endif - -#ifndef VINT32x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 32, 4, 2) -# define VINT32x4_NOT_DEFINED -#endif - -#ifndef VINT32x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 4, 2) -# define VINT32x4_CMPLT_DEFINED -#endif - -#ifndef VINT32x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 4, 2) -# define VINT32x4_CMPEQ_DEFINED -#endif - -#ifndef VINT32x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 4, 2) -# define VINT32x4_CMPGT_DEFINED -#endif - -#ifndef VINT32x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 4, 2) -# define VINT32x4_CMPLE_DEFINED -#endif - -#ifndef VINT32x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 4, 2) -# define VINT32x4_CMPGE_DEFINED -#endif - -#ifndef VINT32x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 32, 4, 2) -# define VINT32x4_MIN_DEFINED -#endif - -#ifndef VINT32x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 32, 4, 2) -# define VINT32x4_MAX_DEFINED -#endif - -#ifndef VINT32x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 4, 2) -# define VINT32x4_RSHIFT_DEFINED -#endif - -#ifndef VINT32x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 4, 2) -# define VINT32x4_LRSHIFT_DEFINED -#endif - -#ifndef VINT32x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 4, 2) -# define VINT32x4_LSHIFT_DEFINED -#endif - - - -/* vint32x4 */ - -#ifndef VUINT32x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 32, 4, 2) -# define VUINT32x4_SPLAT_DEFINED -#endif - -#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 4, 2) -# define VUINT32x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 32, 4, 2) -# define VUINT32x4_LOAD_DEFINED -#endif - -#ifndef VUINT32x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 4, 2) -# define VUINT32x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 32, 4, 2) -# define VUINT32x4_STORE_DEFINED -#endif - -#ifndef VUINT32x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 32, 4, 2) -# define VUINT32x4_ADD_DEFINED -#endif - -#ifndef VUINT32x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 32, 4, 2) -# define VUINT32x4_SUB_DEFINED -#endif - -#ifndef VUINT32x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 32, 4, 2) -# define VUINT32x4_MUL_DEFINED -#endif - -#ifndef VUINT32x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 32, 4, 2) -# define VUINT32x4_DIV_DEFINED -#endif - -#ifndef VUINT32x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 32, 4, 2) -# define VUINT32x4_MOD_DEFINED -#endif - -#ifndef VUINT32x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 32, 4, 2) -# define VUINT32x4_AVG_DEFINED -#endif - -#ifndef VUINT32x4_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 32, 4, 2) -# define VUINT32x4_AND_DEFINED -#endif - -#ifndef VUINT32x4_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 32, 4, 2) -# define VUINT32x4_OR_DEFINED -#endif - -#ifndef VUINT32x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 32, 4, 2) -# define VUINT32x4_XOR_DEFINED -#endif - -#ifndef VUINT32x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 32, 4, 2) -# define VUINT32x4_NOT_DEFINED -#endif - -#ifndef VUINT32x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 32, 4, 2) -# define VUINT32x4_CMPLT_DEFINED -#endif - -#ifndef VUINT32x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 32, 4, 2) -# define VUINT32x4_CMPEQ_DEFINED -#endif - -#ifndef VUINT32x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 32, 4, 2) -# define VUINT32x4_CMPGT_DEFINED -#endif - -#ifndef VUINT32x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 32, 4, 2) -# define VUINT32x4_CMPLE_DEFINED -#endif - -#ifndef VUINT32x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 32, 4, 2) -# define VUINT32x4_CMPGE_DEFINED -#endif - -#ifndef VUINT32x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 32, 4, 2) -# define VUINT32x4_MIN_DEFINED -#endif - -#ifndef VUINT32x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 32, 4, 2) -# define VUINT32x4_MAX_DEFINED -#endif - -#ifndef VUINT32x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 32, 4, 2) -# define VUINT32x4_RSHIFT_DEFINED -#endif - -#ifndef VUINT32x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 32, 4, 2) -# define VUINT32x4_LRSHIFT_DEFINED -#endif - -#ifndef VUINT32x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 32, 4, 2) -# define VUINT32x4_LSHIFT_DEFINED -#endif - - - -/* vuint32x8 */ - -#ifndef VINT32x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 8, 4) -# define VINT32x8_SPLAT_DEFINED -#endif - -#ifndef VINT32x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 8, 4) -# define VINT32x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT32x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 8, 4) -# define VINT32x8_LOAD_DEFINED -#endif - -#ifndef VINT32x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 8, 4) -# define VINT32x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT32x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 32, 8, 4) -# define VINT32x8_STORE_DEFINED -#endif - -#ifndef VINT32x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 32, 8, 4) -# define VINT32x8_ADD_DEFINED -#endif - -#ifndef VINT32x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 32, 8, 4) -# define VINT32x8_SUB_DEFINED -#endif - -#ifndef VINT32x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 32, 8, 4) -# define VINT32x8_MUL_DEFINED -#endif - -#ifndef VINT32x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 32, 8, 4) -# define VINT32x8_DIV_DEFINED -#endif - -#ifndef VINT32x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 32, 8, 4) -# define VINT32x8_MOD_DEFINED -#endif - -#ifndef VINT32x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 32, 8, 4) -# define VINT32x8_AVG_DEFINED -#endif - -#ifndef VINT32x8_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 32, 8, 4) -# define VINT32x8_AND_DEFINED -#endif - -#ifndef VINT32x8_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 32, 8, 4) -# define VINT32x8_OR_DEFINED -#endif - -#ifndef VINT32x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 32, 8, 4) -# define VINT32x8_XOR_DEFINED -#endif - -#ifndef VINT32x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 32, 8, 4) -# define VINT32x8_NOT_DEFINED -#endif - -#ifndef VINT32x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 8, 4) -# define VINT32x8_CMPLT_DEFINED -#endif - -#ifndef VINT32x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 8, 4) -# define VINT32x8_CMPEQ_DEFINED -#endif - -#ifndef VINT32x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 8, 4) -# define VINT32x8_CMPGT_DEFINED -#endif - -#ifndef VINT32x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 8, 4) -# define VINT32x8_CMPLE_DEFINED -#endif - -#ifndef VINT32x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 8, 4) -# define VINT32x8_CMPGE_DEFINED -#endif - -#ifndef VINT32x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 32, 8, 4) -# define VINT32x8_MIN_DEFINED -#endif - -#ifndef VINT32x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 32, 8, 4) -# define VINT32x8_MAX_DEFINED -#endif - -#ifndef VINT32x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 8, 4) -# define VINT32x8_RSHIFT_DEFINED -#endif - -#ifndef VINT32x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 8, 4) -# define VINT32x8_LRSHIFT_DEFINED -#endif - -#ifndef VINT32x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 8, 4) -# define VINT32x8_LSHIFT_DEFINED -#endif - - - -/* vint32x8 */ - -#ifndef VUINT32x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 32, 8, 4) -# define VUINT32x8_SPLAT_DEFINED -#endif - -#ifndef VUINT32x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 8, 4) -# define VUINT32x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 32, 8, 4) -# define VUINT32x8_LOAD_DEFINED -#endif - -#ifndef VUINT32x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 8, 4) -# define VUINT32x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 32, 8, 4) -# define VUINT32x8_STORE_DEFINED -#endif - -#ifndef VUINT32x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 32, 8, 4) -# define VUINT32x8_ADD_DEFINED -#endif - -#ifndef VUINT32x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 32, 8, 4) -# define VUINT32x8_SUB_DEFINED -#endif - -#ifndef VUINT32x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 32, 8, 4) -# define VUINT32x8_MUL_DEFINED -#endif - -#ifndef VUINT32x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 32, 8, 4) -# define VUINT32x8_DIV_DEFINED -#endif - -#ifndef VUINT32x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 32, 8, 4) -# define VUINT32x8_MOD_DEFINED -#endif - -#ifndef VUINT32x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 32, 8, 4) -# define VUINT32x8_AVG_DEFINED -#endif - -#ifndef VUINT32x8_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 32, 8, 4) -# define VUINT32x8_AND_DEFINED -#endif - -#ifndef VUINT32x8_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 32, 8, 4) -# define VUINT32x8_OR_DEFINED -#endif - -#ifndef VUINT32x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 32, 8, 4) -# define VUINT32x8_XOR_DEFINED -#endif - -#ifndef VUINT32x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 32, 8, 4) -# define VUINT32x8_NOT_DEFINED -#endif - -#ifndef VUINT32x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 32, 8, 4) -# define VUINT32x8_CMPLT_DEFINED -#endif - -#ifndef VUINT32x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 32, 8, 4) -# define VUINT32x8_CMPEQ_DEFINED -#endif - -#ifndef VUINT32x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 32, 8, 4) -# define VUINT32x8_CMPGT_DEFINED -#endif - -#ifndef VUINT32x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 32, 8, 4) -# define VUINT32x8_CMPLE_DEFINED -#endif - -#ifndef VUINT32x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 32, 8, 4) -# define VUINT32x8_CMPGE_DEFINED -#endif - -#ifndef VUINT32x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 32, 8, 4) -# define VUINT32x8_MIN_DEFINED -#endif - -#ifndef VUINT32x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 32, 8, 4) -# define VUINT32x8_MAX_DEFINED -#endif - -#ifndef VUINT32x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 32, 8, 4) -# define VUINT32x8_RSHIFT_DEFINED -#endif - -#ifndef VUINT32x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 32, 8, 4) -# define VUINT32x8_LRSHIFT_DEFINED -#endif - -#ifndef VUINT32x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 32, 8, 4) -# define VUINT32x8_LSHIFT_DEFINED -#endif - - - -/* vuint32x16 */ - -#ifndef VINT32x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 16, 8) -# define VINT32x16_SPLAT_DEFINED -#endif - -#ifndef VINT32x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 16, 8) -# define VINT32x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT32x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 16, 8) -# define VINT32x16_LOAD_DEFINED -#endif - -#ifndef VINT32x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 16, 8) -# define VINT32x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT32x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 32, 16, 8) -# define VINT32x16_STORE_DEFINED -#endif - -#ifndef VINT32x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 32, 16, 8) -# define VINT32x16_ADD_DEFINED -#endif - -#ifndef VINT32x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 32, 16, 8) -# define VINT32x16_SUB_DEFINED -#endif - -#ifndef VINT32x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 32, 16, 8) -# define VINT32x16_MUL_DEFINED -#endif - -#ifndef VINT32x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 32, 16, 8) -# define VINT32x16_DIV_DEFINED -#endif - -#ifndef VINT32x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 32, 16, 8) -# define VINT32x16_MOD_DEFINED -#endif - -#ifndef VINT32x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 32, 16, 8) -# define VINT32x16_AVG_DEFINED -#endif - -#ifndef VINT32x16_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 32, 16, 8) -# define VINT32x16_AND_DEFINED -#endif - -#ifndef VINT32x16_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 32, 16, 8) -# define VINT32x16_OR_DEFINED -#endif - -#ifndef VINT32x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 32, 16, 8) -# define VINT32x16_XOR_DEFINED -#endif - -#ifndef VINT32x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 32, 16, 8) -# define VINT32x16_NOT_DEFINED -#endif - -#ifndef VINT32x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 16, 8) -# define VINT32x16_CMPLT_DEFINED -#endif - -#ifndef VINT32x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 16, 8) -# define VINT32x16_CMPEQ_DEFINED -#endif - -#ifndef VINT32x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 16, 8) -# define VINT32x16_CMPGT_DEFINED -#endif - -#ifndef VINT32x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 16, 8) -# define VINT32x16_CMPLE_DEFINED -#endif - -#ifndef VINT32x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 16, 8) -# define VINT32x16_CMPGE_DEFINED -#endif - -#ifndef VINT32x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 32, 16, 8) -# define VINT32x16_MIN_DEFINED -#endif - -#ifndef VINT32x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 32, 16, 8) -# define VINT32x16_MAX_DEFINED -#endif - -#ifndef VINT32x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 16, 8) -# define VINT32x16_RSHIFT_DEFINED -#endif - -#ifndef VINT32x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 16, 8) -# define VINT32x16_LRSHIFT_DEFINED -#endif - -#ifndef VINT32x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 16, 8) -# define VINT32x16_LSHIFT_DEFINED -#endif - - - -/* vint32x16 */ - -#ifndef VUINT32x16_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 32, 16, 8) -# define VUINT32x16_SPLAT_DEFINED -#endif - -#ifndef VUINT32x16_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 16, 8) -# define VUINT32x16_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x16_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 32, 16, 8) -# define VUINT32x16_LOAD_DEFINED -#endif - -#ifndef VUINT32x16_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 16, 8) -# define VUINT32x16_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT32x16_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 32, 16, 8) -# define VUINT32x16_STORE_DEFINED -#endif - -#ifndef VUINT32x16_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 32, 16, 8) -# define VUINT32x16_ADD_DEFINED -#endif - -#ifndef VUINT32x16_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 32, 16, 8) -# define VUINT32x16_SUB_DEFINED -#endif - -#ifndef VUINT32x16_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 32, 16, 8) -# define VUINT32x16_MUL_DEFINED -#endif - -#ifndef VUINT32x16_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 32, 16, 8) -# define VUINT32x16_DIV_DEFINED -#endif - -#ifndef VUINT32x16_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 32, 16, 8) -# define VUINT32x16_MOD_DEFINED -#endif - -#ifndef VUINT32x16_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 32, 16, 8) -# define VUINT32x16_AVG_DEFINED -#endif - -#ifndef VUINT32x16_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 32, 16, 8) -# define VUINT32x16_AND_DEFINED -#endif - -#ifndef VUINT32x16_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 32, 16, 8) -# define VUINT32x16_OR_DEFINED -#endif - -#ifndef VUINT32x16_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 32, 16, 8) -# define VUINT32x16_XOR_DEFINED -#endif - -#ifndef VUINT32x16_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 32, 16, 8) -# define VUINT32x16_NOT_DEFINED -#endif - -#ifndef VUINT32x16_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 32, 16, 8) -# define VUINT32x16_CMPLT_DEFINED -#endif - -#ifndef VUINT32x16_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 32, 16, 8) -# define VUINT32x16_CMPEQ_DEFINED -#endif - -#ifndef VUINT32x16_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 32, 16, 8) -# define VUINT32x16_CMPGT_DEFINED -#endif - -#ifndef VUINT32x16_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 32, 16, 8) -# define VUINT32x16_CMPLE_DEFINED -#endif - -#ifndef VUINT32x16_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 32, 16, 8) -# define VUINT32x16_CMPGE_DEFINED -#endif - -#ifndef VUINT32x16_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 32, 16, 8) -# define VUINT32x16_MIN_DEFINED -#endif - -#ifndef VUINT32x16_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 32, 16, 8) -# define VUINT32x16_MAX_DEFINED -#endif - -#ifndef VUINT32x16_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 32, 16, 8) -# define VUINT32x16_RSHIFT_DEFINED -#endif - -#ifndef VUINT32x16_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 32, 16, 8) -# define VUINT32x16_LRSHIFT_DEFINED -#endif - -#ifndef VUINT32x16_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 32, 16, 8) -# define VUINT32x16_LSHIFT_DEFINED -#endif - - - /* vuint64x2 */ #ifndef VINT64x2_SPLAT_DEFINED @@ -4212,521 +1043,5 @@ VEC_GENERIC_LSHIFT(u, 64, 2) # define VUINT64x2_LSHIFT_DEFINED #endif - - -/* vuint64x4 */ - -#ifndef VINT64x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 64, 4, 2) -# define VINT64x4_SPLAT_DEFINED -#endif - -#ifndef VINT64x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 64, 4, 2) -# define VINT64x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT64x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 64, 4, 2) -# define VINT64x4_LOAD_DEFINED -#endif - -#ifndef VINT64x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 64, 4, 2) -# define VINT64x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT64x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 64, 4, 2) -# define VINT64x4_STORE_DEFINED -#endif - -#ifndef VINT64x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 64, 4, 2) -# define VINT64x4_ADD_DEFINED -#endif - -#ifndef VINT64x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 64, 4, 2) -# define VINT64x4_SUB_DEFINED -#endif - -#ifndef VINT64x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 64, 4, 2) -# define VINT64x4_MUL_DEFINED -#endif - -#ifndef VINT64x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 64, 4, 2) -# define VINT64x4_DIV_DEFINED -#endif - -#ifndef VINT64x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 64, 4, 2) -# define VINT64x4_MOD_DEFINED -#endif - -#ifndef VINT64x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 64, 4, 2) -# define VINT64x4_AVG_DEFINED -#endif - -#ifndef VINT64x4_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 64, 4, 2) -# define VINT64x4_AND_DEFINED -#endif - -#ifndef VINT64x4_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 64, 4, 2) -# define VINT64x4_OR_DEFINED -#endif - -#ifndef VINT64x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 64, 4, 2) -# define VINT64x4_XOR_DEFINED -#endif - -#ifndef VINT64x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 64, 4, 2) -# define VINT64x4_NOT_DEFINED -#endif - -#ifndef VINT64x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 64, 4, 2) -# define VINT64x4_CMPLT_DEFINED -#endif - -#ifndef VINT64x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 64, 4, 2) -# define VINT64x4_CMPEQ_DEFINED -#endif - -#ifndef VINT64x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 64, 4, 2) -# define VINT64x4_CMPGT_DEFINED -#endif - -#ifndef VINT64x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 64, 4, 2) -# define VINT64x4_CMPLE_DEFINED -#endif - -#ifndef VINT64x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 64, 4, 2) -# define VINT64x4_CMPGE_DEFINED -#endif - -#ifndef VINT64x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 64, 4, 2) -# define VINT64x4_MIN_DEFINED -#endif - -#ifndef VINT64x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 64, 4, 2) -# define VINT64x4_MAX_DEFINED -#endif - -#ifndef VINT64x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 64, 4, 2) -# define VINT64x4_RSHIFT_DEFINED -#endif - -#ifndef VINT64x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 64, 4, 2) -# define VINT64x4_LRSHIFT_DEFINED -#endif - -#ifndef VINT64x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 64, 4, 2) -# define VINT64x4_LSHIFT_DEFINED -#endif - - - -/* vint64x4 */ - -#ifndef VUINT64x4_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 64, 4, 2) -# define VUINT64x4_SPLAT_DEFINED -#endif - -#ifndef VUINT64x4_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 64, 4, 2) -# define VUINT64x4_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT64x4_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 64, 4, 2) -# define VUINT64x4_LOAD_DEFINED -#endif - -#ifndef VUINT64x4_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 64, 4, 2) -# define VUINT64x4_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT64x4_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 64, 4, 2) -# define VUINT64x4_STORE_DEFINED -#endif - -#ifndef VUINT64x4_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 64, 4, 2) -# define VUINT64x4_ADD_DEFINED -#endif - -#ifndef VUINT64x4_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 64, 4, 2) -# define VUINT64x4_SUB_DEFINED -#endif - -#ifndef VUINT64x4_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 64, 4, 2) -# define VUINT64x4_MUL_DEFINED -#endif - -#ifndef VUINT64x4_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 64, 4, 2) -# define VUINT64x4_DIV_DEFINED -#endif - -#ifndef VUINT64x4_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 64, 4, 2) -# define VUINT64x4_MOD_DEFINED -#endif - -#ifndef VUINT64x4_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 64, 4, 2) -# define VUINT64x4_AVG_DEFINED -#endif - -#ifndef VUINT64x4_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 64, 4, 2) -# define VUINT64x4_AND_DEFINED -#endif - -#ifndef VUINT64x4_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 64, 4, 2) -# define VUINT64x4_OR_DEFINED -#endif - -#ifndef VUINT64x4_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 64, 4, 2) -# define VUINT64x4_XOR_DEFINED -#endif - -#ifndef VUINT64x4_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 64, 4, 2) -# define VUINT64x4_NOT_DEFINED -#endif - -#ifndef VUINT64x4_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 64, 4, 2) -# define VUINT64x4_CMPLT_DEFINED -#endif - -#ifndef VUINT64x4_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 64, 4, 2) -# define VUINT64x4_CMPEQ_DEFINED -#endif - -#ifndef VUINT64x4_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 64, 4, 2) -# define VUINT64x4_CMPGT_DEFINED -#endif - -#ifndef VUINT64x4_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 64, 4, 2) -# define VUINT64x4_CMPLE_DEFINED -#endif - -#ifndef VUINT64x4_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 64, 4, 2) -# define VUINT64x4_CMPGE_DEFINED -#endif - -#ifndef VUINT64x4_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 64, 4, 2) -# define VUINT64x4_MIN_DEFINED -#endif - -#ifndef VUINT64x4_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 64, 4, 2) -# define VUINT64x4_MAX_DEFINED -#endif - -#ifndef VUINT64x4_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 64, 4, 2) -# define VUINT64x4_RSHIFT_DEFINED -#endif - -#ifndef VUINT64x4_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 64, 4, 2) -# define VUINT64x4_LRSHIFT_DEFINED -#endif - -#ifndef VUINT64x4_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 64, 4, 2) -# define VUINT64x4_LSHIFT_DEFINED -#endif - - - -/* vuint64x8 */ - -#ifndef VINT64x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(/* nothing */, 64, 8, 4) -# define VINT64x8_SPLAT_DEFINED -#endif - -#ifndef VINT64x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 64, 8, 4) -# define VINT64x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VINT64x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(/* nothing */, 64, 8, 4) -# define VINT64x8_LOAD_DEFINED -#endif - -#ifndef VINT64x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 64, 8, 4) -# define VINT64x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VINT64x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(/* nothing */, 64, 8, 4) -# define VINT64x8_STORE_DEFINED -#endif - -#ifndef VINT64x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(/* nothing */, 64, 8, 4) -# define VINT64x8_ADD_DEFINED -#endif - -#ifndef VINT64x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(/* nothing */, 64, 8, 4) -# define VINT64x8_SUB_DEFINED -#endif - -#ifndef VINT64x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(/* nothing */, 64, 8, 4) -# define VINT64x8_MUL_DEFINED -#endif - -#ifndef VINT64x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(/* nothing */, 64, 8, 4) -# define VINT64x8_DIV_DEFINED -#endif - -#ifndef VINT64x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(/* nothing */, 64, 8, 4) -# define VINT64x8_MOD_DEFINED -#endif - -#ifndef VINT64x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(/* nothing */, 64, 8, 4) -# define VINT64x8_AVG_DEFINED -#endif - -#ifndef VINT64x8_AND_DEFINED -VEC_GENERIC_DBL_AND(/* nothing */, 64, 8, 4) -# define VINT64x8_AND_DEFINED -#endif - -#ifndef VINT64x8_OR_DEFINED -VEC_GENERIC_DBL_OR(/* nothing */, 64, 8, 4) -# define VINT64x8_OR_DEFINED -#endif - -#ifndef VINT64x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(/* nothing */, 64, 8, 4) -# define VINT64x8_XOR_DEFINED -#endif - -#ifndef VINT64x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(/* nothing */, 64, 8, 4) -# define VINT64x8_NOT_DEFINED -#endif - -#ifndef VINT64x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(/* nothing */, 64, 8, 4) -# define VINT64x8_CMPLT_DEFINED -#endif - -#ifndef VINT64x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(/* nothing */, 64, 8, 4) -# define VINT64x8_CMPEQ_DEFINED -#endif - -#ifndef VINT64x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(/* nothing */, 64, 8, 4) -# define VINT64x8_CMPGT_DEFINED -#endif - -#ifndef VINT64x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(/* nothing */, 64, 8, 4) -# define VINT64x8_CMPLE_DEFINED -#endif - -#ifndef VINT64x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(/* nothing */, 64, 8, 4) -# define VINT64x8_CMPGE_DEFINED -#endif - -#ifndef VINT64x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(/* nothing */, 64, 8, 4) -# define VINT64x8_MIN_DEFINED -#endif - -#ifndef VINT64x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(/* nothing */, 64, 8, 4) -# define VINT64x8_MAX_DEFINED -#endif - -#ifndef VINT64x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(/* nothing */, 64, 8, 4) -# define VINT64x8_RSHIFT_DEFINED -#endif - -#ifndef VINT64x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 64, 8, 4) -# define VINT64x8_LRSHIFT_DEFINED -#endif - -#ifndef VINT64x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(/* nothing */, 64, 8, 4) -# define VINT64x8_LSHIFT_DEFINED -#endif - - - -/* vint64x8 */ - -#ifndef VUINT64x8_SPLAT_DEFINED -VEC_GENERIC_DBL_SPLAT(u, 64, 8, 4) -# define VUINT64x8_SPLAT_DEFINED -#endif - -#ifndef VUINT64x8_LOAD_ALIGNED_DEFINED -VEC_GENERIC_DBL_LOAD_ALIGNED(u, 64, 8, 4) -# define VUINT64x8_LOAD_ALIGNED_DEFINED -#endif - -#ifndef VUINT64x8_LOAD_DEFINED -VEC_GENERIC_DBL_LOAD(u, 64, 8, 4) -# define VUINT64x8_LOAD_DEFINED -#endif - -#ifndef VUINT64x8_STORE_ALIGNED_DEFINED -VEC_GENERIC_DBL_STORE_ALIGNED(u, 64, 8, 4) -# define VUINT64x8_STORE_ALIGNED_DEFINED -#endif - -#ifndef VUINT64x8_STORE_DEFINED -VEC_GENERIC_DBL_STORE(u, 64, 8, 4) -# define VUINT64x8_STORE_DEFINED -#endif - -#ifndef VUINT64x8_ADD_DEFINED -VEC_GENERIC_DBL_ADD(u, 64, 8, 4) -# define VUINT64x8_ADD_DEFINED -#endif - -#ifndef VUINT64x8_SUB_DEFINED -VEC_GENERIC_DBL_SUB(u, 64, 8, 4) -# define VUINT64x8_SUB_DEFINED -#endif - -#ifndef VUINT64x8_MUL_DEFINED -VEC_GENERIC_DBL_MUL(u, 64, 8, 4) -# define VUINT64x8_MUL_DEFINED -#endif - -#ifndef VUINT64x8_DIV_DEFINED -VEC_GENERIC_DBL_DIV(u, 64, 8, 4) -# define VUINT64x8_DIV_DEFINED -#endif - -#ifndef VUINT64x8_MOD_DEFINED -VEC_GENERIC_DBL_MOD(u, 64, 8, 4) -# define VUINT64x8_MOD_DEFINED -#endif - -#ifndef VUINT64x8_AVG_DEFINED -VEC_GENERIC_DBL_AVG(u, 64, 8, 4) -# define VUINT64x8_AVG_DEFINED -#endif - -#ifndef VUINT64x8_AND_DEFINED -VEC_GENERIC_DBL_AND(u, 64, 8, 4) -# define VUINT64x8_AND_DEFINED -#endif - -#ifndef VUINT64x8_OR_DEFINED -VEC_GENERIC_DBL_OR(u, 64, 8, 4) -# define VUINT64x8_OR_DEFINED -#endif - -#ifndef VUINT64x8_XOR_DEFINED -VEC_GENERIC_DBL_XOR(u, 64, 8, 4) -# define VUINT64x8_XOR_DEFINED -#endif - -#ifndef VUINT64x8_NOT_DEFINED -VEC_GENERIC_DBL_NOT(u, 64, 8, 4) -# define VUINT64x8_NOT_DEFINED -#endif - -#ifndef VUINT64x8_CMPLT_DEFINED -VEC_GENERIC_DBL_CMPLT(u, 64, 8, 4) -# define VUINT64x8_CMPLT_DEFINED -#endif - -#ifndef VUINT64x8_CMPEQ_DEFINED -VEC_GENERIC_DBL_CMPEQ(u, 64, 8, 4) -# define VUINT64x8_CMPEQ_DEFINED -#endif - -#ifndef VUINT64x8_CMPGT_DEFINED -VEC_GENERIC_DBL_CMPGT(u, 64, 8, 4) -# define VUINT64x8_CMPGT_DEFINED -#endif - -#ifndef VUINT64x8_CMPLE_DEFINED -VEC_GENERIC_DBL_CMPLE(u, 64, 8, 4) -# define VUINT64x8_CMPLE_DEFINED -#endif - -#ifndef VUINT64x8_CMPGE_DEFINED -VEC_GENERIC_DBL_CMPGE(u, 64, 8, 4) -# define VUINT64x8_CMPGE_DEFINED -#endif - -#ifndef VUINT64x8_MIN_DEFINED -VEC_GENERIC_DBL_MIN(u, 64, 8, 4) -# define VUINT64x8_MIN_DEFINED -#endif - -#ifndef VUINT64x8_MAX_DEFINED -VEC_GENERIC_DBL_MAX(u, 64, 8, 4) -# define VUINT64x8_MAX_DEFINED -#endif - -#ifndef VUINT64x8_RSHIFT_DEFINED -VEC_GENERIC_DBL_RSHIFT(u, 64, 8, 4) -# define VUINT64x8_RSHIFT_DEFINED -#endif - -#ifndef VUINT64x8_LRSHIFT_DEFINED -VEC_GENERIC_DBL_LRSHIFT(u, 64, 8, 4) -# define VUINT64x8_LRSHIFT_DEFINED -#endif - -#ifndef VUINT64x8_LSHIFT_DEFINED -VEC_GENERIC_DBL_LSHIFT(u, 64, 8, 4) -# define VUINT64x8_LSHIFT_DEFINED -#endif - #endif /* VEC_IMPL_GENERIC_H_ */
--- a/include/vec/impl/ppc/altivec.h Sun Apr 27 02:49:53 2025 -0400 +++ b/include/vec/impl/ppc/altivec.h Mon Apr 28 16:31:59 2025 -0400 @@ -22,231 +22,1116 @@ * SOFTWARE. **/ -/* Altivec vector support. */ +/* This file is automatically generated! Do not edit it directly! + * Edit the code that generates it in utils/gengcc.c --paper */ #ifndef VEC_IMPL_PPC_ALTIVEC_H_ #define VEC_IMPL_PPC_ALTIVEC_H_ -/* GCC 4.2.1 on Mac OS X doesn't have these for some reason */ + + + +/* vuint8x16 */ + +#ifdef vec_splats +#ifndef VINT8x16_SPLAT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_splat(vec_int8 x) +{ + vint8x16 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT8x16_SPLAT_DEFINED +#endif +#endif +#ifndef VINT8x16_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_load_aligned(const vec_int8 x[16]) +{ + vint8x16 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT8x16_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT8x16_LOAD_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_load(const vec_int8 x[16]) +{ + vint8x16 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT8x16_LOAD_DEFINED +#endif +#ifndef VINT8x16_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint8x16_store_aligned(vint8x16 vec, vec_int8 arr[16]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT8x16_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT8x16_STORE_DEFINED +VEC_FUNC_IMPL void vint8x16_store(vint8x16 vec, vec_int8 arr[16]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT8x16_STORE_DEFINED +#endif +#ifndef VINT8x16_ADD_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_add(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_ADD_DEFINED +#endif +#ifndef VINT8x16_SUB_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_sub(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_SUB_DEFINED +#endif #ifdef vec_mul -# define VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size) \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_mul(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_mul(vec1.altivec, vec2.altivec); \ - return vec; \ - } -# define VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size) \ - v##sign##int##bits##x##size##_altivec_mul -#else -# define VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size) -# define VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size) NULL +#ifndef VINT8x16_MUL_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_mul(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MUL_DEFINED +#endif +#endif +#ifndef VINT8x16_AND_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_and(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_AND_DEFINED +#endif +#ifndef VINT8x16_OR_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_or(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_OR_DEFINED +#endif +#ifndef VINT8x16_XOR_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_xor(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_XOR_DEFINED +#endif +#ifndef VINT8x16_CMPLT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPLT_DEFINED +#endif +#ifndef VINT8x16_CMPEQ_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPEQ_DEFINED +#endif +#ifndef VINT8x16_CMPGT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_CMPGT_DEFINED +#endif +#ifndef VINT8x16_MIN_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MIN_DEFINED +#endif +#ifndef VINT8x16_MAX_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_MAX_DEFINED +#endif +#ifndef VINT8x16_AVG_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_AVG_DEFINED +#endif +#ifndef VINT8x16_LSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_LSHIFT_DEFINED +#endif +#ifndef VINT8x16_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = (vector signed char)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_LRSHIFT_DEFINED +#endif +#ifndef VINT8x16_RSHIFT_DEFINED +VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2) +{ + vint8x16 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT8x16_RSHIFT_DEFINED #endif + +/* vint8x16 */ + #ifdef vec_splats -# define VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size) \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_splat(vec_##sign##int##bits x) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_splats(x); \ - return vec; \ - } -# define VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size) \ - v##sign##int##bits##x##size##_altivec_splat -#else -# define VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size) -# define VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size) NULL +#ifndef VUINT8x16_SPLAT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_splat(vec_uint8 x) +{ + vuint8x16 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT8x16_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_load_aligned(const vec_uint8 x[16]) +{ + vuint8x16 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT8x16_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT8x16_LOAD_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_load(const vec_uint8 x[16]) +{ + vuint8x16 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT8x16_LOAD_DEFINED +#endif +#ifndef VUINT8x16_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint8x16_store_aligned(vuint8x16 vec, vec_uint8 arr[16]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT8x16_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT8x16_STORE_DEFINED +VEC_FUNC_IMPL void vuint8x16_store(vuint8x16 vec, vec_uint8 arr[16]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT8x16_STORE_DEFINED +#endif +#ifndef VUINT8x16_ADD_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_add(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_ADD_DEFINED +#endif +#ifndef VUINT8x16_SUB_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_sub(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT8x16_MUL_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_mul(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MUL_DEFINED +#endif +#endif +#ifndef VUINT8x16_AND_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_and(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_AND_DEFINED +#endif +#ifndef VUINT8x16_OR_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_or(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_OR_DEFINED +#endif +#ifndef VUINT8x16_XOR_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_xor(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_XOR_DEFINED +#endif +#ifndef VUINT8x16_CMPLT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPLT_DEFINED +#endif +#ifndef VUINT8x16_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPEQ_DEFINED +#endif +#ifndef VUINT8x16_CMPGT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_CMPGT_DEFINED +#endif +#ifndef VUINT8x16_MIN_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MIN_DEFINED +#endif +#ifndef VUINT8x16_MAX_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_MAX_DEFINED +#endif +#ifndef VUINT8x16_AVG_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_AVG_DEFINED +#endif +#ifndef VUINT8x16_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_LSHIFT_DEFINED +#endif +#ifndef VUINT8x16_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = (vector unsigned char)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_LRSHIFT_DEFINED +#endif +#ifndef VUINT8x16_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2) +{ + vuint8x16 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT8x16_RSHIFT_DEFINED +#endif + + +/* vuint16x8 */ + +#ifdef vec_splats +#ifndef VINT16x8_SPLAT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_splat(vec_int16 x) +{ + vint16x8 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT16x8_SPLAT_DEFINED +#endif +#endif +#ifndef VINT16x8_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_load_aligned(const vec_int16 x[8]) +{ + vint16x8 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT16x8_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT16x8_LOAD_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_load(const vec_int16 x[8]) +{ + vint16x8 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT16x8_LOAD_DEFINED +#endif +#ifndef VINT16x8_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint16x8_store_aligned(vint16x8 vec, vec_int16 arr[8]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT16x8_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT16x8_STORE_DEFINED +VEC_FUNC_IMPL void vint16x8_store(vint16x8 vec, vec_int16 arr[8]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT16x8_STORE_DEFINED +#endif +#ifndef VINT16x8_ADD_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_add(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_ADD_DEFINED +#endif +#ifndef VINT16x8_SUB_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_sub(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VINT16x8_MUL_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_mul(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MUL_DEFINED +#endif +#endif +#ifndef VINT16x8_AND_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_and(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_AND_DEFINED +#endif +#ifndef VINT16x8_OR_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_or(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_OR_DEFINED +#endif +#ifndef VINT16x8_XOR_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_xor(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_XOR_DEFINED +#endif +#ifndef VINT16x8_CMPLT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPLT_DEFINED +#endif +#ifndef VINT16x8_CMPEQ_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPEQ_DEFINED +#endif +#ifndef VINT16x8_CMPGT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_CMPGT_DEFINED +#endif +#ifndef VINT16x8_MIN_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MIN_DEFINED +#endif +#ifndef VINT16x8_MAX_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_MAX_DEFINED +#endif +#ifndef VINT16x8_AVG_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_AVG_DEFINED +#endif +#ifndef VINT16x8_LSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_LSHIFT_DEFINED +#endif +#ifndef VINT16x8_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = (vector signed short)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_LRSHIFT_DEFINED +#endif +#ifndef VINT16x8_RSHIFT_DEFINED +VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2) +{ + vint16x8 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT16x8_RSHIFT_DEFINED #endif -#define VEC_ALTIVEC_uRSHIFT vec_sr -#define VEC_ALTIVEC_RSHIFT vec_sra + +/* vint16x8 */ -#define VEC_ALTIVEC_DEFINE_uLRSHIFT(sign, csign, bits, size) \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_lrshift(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_sr(vec1.altivec, vec2.altivec); \ - return vec; \ - } -#define VEC_ALTIVEC_STRUCT_uLRSHIFT(sign, csign, bits, size) \ - v##sign##int##bits##x##size##_altivec_lrshift +#ifdef vec_splats +#ifndef VUINT16x8_SPLAT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_splat(vec_uint16 x) +{ + vuint16x8 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT16x8_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_load_aligned(const vec_uint16 x[8]) +{ + vuint16x8 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT16x8_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT16x8_LOAD_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_load(const vec_uint16 x[8]) +{ + vuint16x8 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT16x8_LOAD_DEFINED +#endif +#ifndef VUINT16x8_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint16x8_store_aligned(vuint16x8 vec, vec_uint16 arr[8]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT16x8_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT16x8_STORE_DEFINED +VEC_FUNC_IMPL void vuint16x8_store(vuint16x8 vec, vec_uint16 arr[8]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT16x8_STORE_DEFINED +#endif +#ifndef VUINT16x8_ADD_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_add(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_ADD_DEFINED +#endif +#ifndef VUINT16x8_SUB_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_sub(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT16x8_MUL_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_mul(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MUL_DEFINED +#endif +#endif +#ifndef VUINT16x8_AND_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_and(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_AND_DEFINED +#endif +#ifndef VUINT16x8_OR_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_or(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_OR_DEFINED +#endif +#ifndef VUINT16x8_XOR_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_xor(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_XOR_DEFINED +#endif +#ifndef VUINT16x8_CMPLT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPLT_DEFINED +#endif +#ifndef VUINT16x8_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPEQ_DEFINED +#endif +#ifndef VUINT16x8_CMPGT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_CMPGT_DEFINED +#endif +#ifndef VUINT16x8_MIN_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MIN_DEFINED +#endif +#ifndef VUINT16x8_MAX_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_MAX_DEFINED +#endif +#ifndef VUINT16x8_AVG_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_AVG_DEFINED +#endif +#ifndef VUINT16x8_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_LSHIFT_DEFINED +#endif +#ifndef VUINT16x8_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = (vector unsigned short)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_LRSHIFT_DEFINED +#endif +#ifndef VUINT16x8_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2) +{ + vuint16x8 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT16x8_RSHIFT_DEFINED +#endif -#define VEC_ALTIVEC_DEFINE_LRSHIFT(sign, csign, bits, size) -#define VEC_ALTIVEC_STRUCT_LRSHIFT(sign, csign, bits, size) NULL -#define VEC_ALTIVEC_CAST_BOOL_8 (vector signed char) -#define VEC_ALTIVEC_CAST_BOOL_U8 (vector unsigned char) -#define VEC_ALTIVEC_CAST_BOOL_16 (vector signed short) -#define VEC_ALTIVEC_CAST_BOOL_U16 (vector unsigned short) -#define VEC_ALTIVEC_CAST_BOOL_32 (vector signed int) -#define VEC_ALTIVEC_CAST_BOOL_U32 (vector unsigned int) +/* vuint32x4 */ -/* Since altivec conveniently made their API super user friendly, we can just use - * one giant macro to define literally everything */ -#define VEC_DEFINE_OPERATIONS_SIGN(sign, csign, bits, size) \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_load_aligned(const vec_##sign##int##bits in[size]) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_ld(0, in); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_load(const vec_##sign##int##bits in[size]) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_perm(vec_ld(0, in), vec_ld(16, in), vec_lvsl(0, in)); \ - return vec; \ - } \ - \ - static void v##sign##int##bits##x##size##_altivec_store_aligned(v##sign##int##bits##x##size vec, vec_##sign##int##bits out[size]) \ - { \ - vec_st(vec.altivec, 0, out); \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_add(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_add(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_sub(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_sub(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size) \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_lshift(v##sign##int##bits##x##size vec1, vuint##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_sl(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_rshift(v##sign##int##bits##x##size vec1, vuint##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_##sign##RSHIFT(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - VEC_ALTIVEC_DEFINE_##sign##LRSHIFT(sign, csign, bits, size) \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_avg(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_and(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_and(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_or(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_or(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_xor(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = vec_xor(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size) \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmplt(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_cmplt(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmple(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_or(vec_cmplt(vec1.altivec, vec2.altivec), vec_cmpeq(vec1.altivec, vec2.altivec)); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpeq(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_cmpeq(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpge(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_or(vec_cmpgt(vec1.altivec, vec2.altivec), vec_cmpeq(vec1.altivec, vec2.altivec)); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpgt(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \ - { \ - v##sign##int##bits##x##size vec; \ - vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_cmpgt(vec1.altivec, vec2.altivec); \ - return vec; \ - } \ - \ - static v##sign##int##bits##x##size##_impl v##sign##int##bits##x##size##_impl_altivec = { \ - VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size), \ - v##sign##int##bits##x##size##_altivec_load_aligned, \ - v##sign##int##bits##x##size##_altivec_load, \ - v##sign##int##bits##x##size##_altivec_store_aligned, \ - /* .store = */ NULL, \ - v##sign##int##bits##x##size##_altivec_add, \ - v##sign##int##bits##x##size##_altivec_sub, \ - VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size), \ - /* .div = */ NULL, \ - v##sign##int##bits##x##size##_altivec_avg, \ - v##sign##int##bits##x##size##_altivec_and, \ - v##sign##int##bits##x##size##_altivec_or, \ - v##sign##int##bits##x##size##_altivec_xor, \ - /* .not = */ NULL, \ - v##sign##int##bits##x##size##_altivec_lshift, \ - v##sign##int##bits##x##size##_altivec_rshift, \ - VEC_ALTIVEC_STRUCT_##sign##LRSHIFT(sign, csign, bits, size), \ - v##sign##int##bits##x##size##_altivec_cmplt, \ - v##sign##int##bits##x##size##_altivec_cmple, \ - v##sign##int##bits##x##size##_altivec_cmpeq, \ - v##sign##int##bits##x##size##_altivec_cmpge, \ - v##sign##int##bits##x##size##_altivec_cmpgt, \ - }; +#ifdef vec_splats +#ifndef VINT32x4_SPLAT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_splat(vec_int32 x) +{ + vint32x4 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VINT32x4_SPLAT_DEFINED +#endif +#endif +#ifndef VINT32x4_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_load_aligned(const vec_int32 x[4]) +{ + vint32x4 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VINT32x4_LOAD_ALIGNED_DEFINED +#endif +#ifndef VINT32x4_LOAD_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_load(const vec_int32 x[4]) +{ + vint32x4 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VINT32x4_LOAD_DEFINED +#endif +#ifndef VINT32x4_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vint32x4_store_aligned(vint32x4 vec, vec_int32 arr[4]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VINT32x4_STORE_ALIGNED_DEFINED +#endif +#ifndef VINT32x4_STORE_DEFINED +VEC_FUNC_IMPL void vint32x4_store(vint32x4 vec, vec_int32 arr[4]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VINT32x4_STORE_DEFINED +#endif +#ifndef VINT32x4_ADD_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_add(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_ADD_DEFINED +#endif +#ifndef VINT32x4_SUB_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_sub(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VINT32x4_MUL_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_mul(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MUL_DEFINED +#endif +#endif +#ifndef VINT32x4_AND_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_and(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_AND_DEFINED +#endif +#ifndef VINT32x4_OR_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_or(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_OR_DEFINED +#endif +#ifndef VINT32x4_XOR_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_xor(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_XOR_DEFINED +#endif +#ifndef VINT32x4_CMPLT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPLT_DEFINED +#endif +#ifndef VINT32x4_CMPEQ_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPEQ_DEFINED +#endif +#ifndef VINT32x4_CMPGT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_CMPGT_DEFINED +#endif +#ifndef VINT32x4_MIN_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MIN_DEFINED +#endif +#ifndef VINT32x4_MAX_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_MAX_DEFINED +#endif +#ifndef VINT32x4_AVG_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_AVG_DEFINED +#endif +#ifndef VINT32x4_LSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_LSHIFT_DEFINED +#endif +#ifndef VINT32x4_LRSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = (vector signed int)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_LRSHIFT_DEFINED +#endif +#ifndef VINT32x4_RSHIFT_DEFINED +VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2) +{ + vint32x4 vec; + vec.altivec = vec_sra(vec1.altivec, vec2.altivec); + return vec; +} +# define VINT32x4_RSHIFT_DEFINED +#endif + -#define VEC_DEFINE_OPERATIONS(bits, size) \ - VEC_DEFINE_OPERATIONS_SIGN( , , bits, size) \ - VEC_DEFINE_OPERATIONS_SIGN(u, U, bits, size) - -VEC_DEFINE_OPERATIONS(8, 16) -VEC_DEFINE_OPERATIONS(16, 8) -VEC_DEFINE_OPERATIONS(32, 4) -//#ifdef VEC_COMPILER_HAS_ALTIVEC_VSX -//VEC_DEFINE_OPERATIONS(64, 2) -//#endif +/* vint32x4 */ -#undef VEC_DEFINE_OPERATIONS -#undef VEC_DEFINE_OPERATIONS_SIGN -#undef VEC_ALTIVEC_DEFINE_MUL -#undef VEC_ALTIVEC_STRUCT_MUL -#undef VEC_ALTIVEC_DEFINE_LRSHIFT -#undef VEC_ALTIVEC_STRUCT_LRSHIFT -#undef VEC_ALTIVEC_DEFINE_uLRSHIFT -#undef VEC_ALTIVEC_STRUCT_uLRSHIFT -#undef VEC_ALTIVEC_DEFINE_SPLAT -#undef VEC_ALTIVEC_STRUCT_SPLAT -#undef VEC_ALTIVEC_uRSHIFT -#undef VEC_ALTIVEC_RSHIFT +#ifdef vec_splats +#ifndef VUINT32x4_SPLAT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_splat(vec_uint32 x) +{ + vuint32x4 vec; + vec.altivec = vec_splats(x); + return vec; +} +# define VUINT32x4_SPLAT_DEFINED +#endif +#endif +#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_load_aligned(const vec_uint32 x[4]) +{ + vuint32x4 vec; + vec.altivec = vec_ld(0, x); + return vec; +} +# define VUINT32x4_LOAD_ALIGNED_DEFINED +#endif +#ifndef VUINT32x4_LOAD_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_load(const vec_uint32 x[4]) +{ + vuint32x4 vec; + vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x)); + return vec; +} +# define VUINT32x4_LOAD_DEFINED +#endif +#ifndef VUINT32x4_STORE_ALIGNED_DEFINED +VEC_FUNC_IMPL void vuint32x4_store_aligned(vuint32x4 vec, vec_uint32 arr[4]) +{ + vec_st(vec.altivec, 0, arr); +} +# define VUINT32x4_STORE_ALIGNED_DEFINED +#endif +#ifndef VUINT32x4_STORE_DEFINED +VEC_FUNC_IMPL void vuint32x4_store(vuint32x4 vec, vec_uint32 arr[4]) +{ + memcpy(arr, &vec, sizeof(vec)); +} +# define VUINT32x4_STORE_DEFINED +#endif +#ifndef VUINT32x4_ADD_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_add(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_add(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_ADD_DEFINED +#endif +#ifndef VUINT32x4_SUB_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_sub(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sub(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_SUB_DEFINED +#endif +#ifdef vec_mul +#ifndef VUINT32x4_MUL_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_mul(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_mul(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MUL_DEFINED +#endif +#endif +#ifndef VUINT32x4_AND_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_and(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_and(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_AND_DEFINED +#endif +#ifndef VUINT32x4_OR_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_or(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_or(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_OR_DEFINED +#endif +#ifndef VUINT32x4_XOR_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_xor(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_xor(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_XOR_DEFINED +#endif +#ifndef VUINT32x4_CMPLT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmplt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPLT_DEFINED +#endif +#ifndef VUINT32x4_CMPEQ_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmpeq(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPEQ_DEFINED +#endif +#ifndef VUINT32x4_CMPGT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_cmpgt(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_CMPGT_DEFINED +#endif +#ifndef VUINT32x4_MIN_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_min(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MIN_DEFINED +#endif +#ifndef VUINT32x4_MAX_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_max(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_MAX_DEFINED +#endif +#ifndef VUINT32x4_AVG_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_avg(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_AVG_DEFINED +#endif +#ifndef VUINT32x4_LSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sl(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_LSHIFT_DEFINED +#endif +#ifndef VUINT32x4_LRSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = (vector unsigned int)vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_LRSHIFT_DEFINED +#endif +#ifndef VUINT32x4_RSHIFT_DEFINED +VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2) +{ + vuint32x4 vec; + vec.altivec = vec_sr(vec1.altivec, vec2.altivec); + return vec; +} +# define VUINT32x4_RSHIFT_DEFINED +#endif +#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */ -#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */
--- a/include/vec/vec.h Sun Apr 27 02:49:53 2025 -0400 +++ b/include/vec/vec.h Mon Apr 28 16:31:59 2025 -0400 @@ -355,7 +355,7 @@ return xx.d; } -VEC_FUNC_IMPL vec_intmax vec_avg(vec_intmax x, vec_intmax y) +VEC_FUNC_IMPL vec_intmax vec_imavg(vec_intmax x, vec_intmax y) { vec_intmax x_d_rem = (x % 2); vec_intmax y_d_rem = (y % 2); @@ -365,7 +365,7 @@ return ((x / 2) + (y / 2)) + (rem_d_quot) + (rem_d_rem == 1); } -VEC_FUNC_IMPL vec_uintmax vec_uavg(vec_uintmax x, vec_uintmax y) +VEC_FUNC_IMPL vec_uintmax vec_imuavg(vec_uintmax x, vec_uintmax y) { return (x >> 1) + (y >> 1) + ((x | y) & 1); } @@ -1031,7 +1031,7 @@ } vint64x8; /* ------------------------------------------------------------------------ */ -/* finally; we can import the real implementations */ +/* x86 */ #ifdef VEC_COMPILER_HAS_AVX512BW # include "impl/x86/avx512bw.h" @@ -1061,11 +1061,31 @@ # include "impl/x86/mmx.h" #endif +/* ------------------------------------------------------------------------ */ +/* PowerPC */ + +#ifdef VEC_COMPILER_HAS_ALTIVEC +# include "impl/ppc/altivec.h" +#endif + +/* ------------------------------------------------------------------------ */ +/* By this point, if we've defined native intrinsics, we'll just want to + * double them, rather than use GCC extensions. + * In particular with very old GCC, it can generate very bad asm that + * can perform even worse than non-vectorized code. */ + +#include "impl/double.h" + +/* ------------------------------------------------------------------------ */ +/* Use GCC's vector extensions, if available. */ + #ifdef VEC_COMPILER_HAS_GCC_VECTORS # include "impl/gcc.h" #endif +/* Fill in anything remaining with a generic array-based implementation. */ #include "impl/generic.h" +#include "impl/double.h" /* ------------------------------------------------------------------------ */
--- a/test/Makefile.ppc Sun Apr 27 02:49:53 2025 -0400 +++ b/test/Makefile.ppc Mon Apr 28 16:31:59 2025 -0400 @@ -1,3 +1,4 @@ CPPFLAGS += -maltivec +LDFLAGS += -maltivec -include Makefile.template \ No newline at end of file +include Makefile.template
--- a/test/Makefile.template Sun Apr 27 02:49:53 2025 -0400 +++ b/test/Makefile.template Mon Apr 28 16:31:59 2025 -0400 @@ -1,4 +1,4 @@ -CPPFLAGS += -g -O2 -I../include -Wall -Wpedantic -Werror=strict-aliasing +CPPFLAGS += -g -O2 -I../include -Wall CFLAGS += $(CPPFLAGS) -std=c99 CXXFLAGS += $(CPPFLAGS) -std=c++11
--- a/test/test.c Sun Apr 27 02:49:53 2025 -0400 +++ b/test/test.c Mon Apr 28 16:31:59 2025 -0400 @@ -111,10 +111,12 @@ // ------------------------------------------------------------ +#if 0 #include "test_align.h" #include "test_arith.h" #include "test_compare.h" #include "test_shift.h" +#endif #include "test_benchmark.h" // ------------------------------------------------------------ @@ -125,10 +127,12 @@ srand(time(NULL)); +#if 0 ret |= test_align(); ret |= test_arith(); ret |= test_compare(); ret |= test_shift(); +#endif test_benchmark();
--- a/test/test_arith.h Sun Apr 27 02:49:53 2025 -0400 +++ b/test/test_arith.h Mon Apr 28 16:31:59 2025 -0400 @@ -40,7 +40,7 @@ CREATE_TEST(sign, psign, csign, bits, size, and, orig_a[i] & orig_b[i]) \ CREATE_TEST(sign, psign, csign, bits, size, or, orig_a[i] | orig_b[i]) \ CREATE_TEST(sign, psign, csign, bits, size, xor, orig_a[i] ^ orig_b[i]) \ - CREATE_TEST(sign, psign, csign, bits, size, avg, (vec_##sign##int##bits)vec_##sign##avg(orig_a[i], orig_b[i])) \ + CREATE_TEST(sign, psign, csign, bits, size, avg, (vec_##sign##int##bits)vec_im##sign##avg(orig_a[i], orig_b[i])) \ CREATE_TEST_SHIFT(sign, psign, csign, bits, size, rshift, vec_##sign##rshift(orig_a[i], orig_b[i])) \ CREATE_TEST_SHIFT(sign, psign, csign, bits, size, lshift, vec_##sign##lshift(orig_a[i], orig_b[i])) \ CREATE_TEST_SHIFT(sign, psign, csign, bits, size, lrshift, vec_urshift((vec_uint##bits)orig_a[i], orig_b[i])) \
--- a/test/test_benchmark.h Sun Apr 27 02:49:53 2025 -0400 +++ b/test/test_benchmark.h Mon Apr 28 16:31:59 2025 -0400 @@ -14,12 +14,8 @@ printf("\nsigned 16-bit audio sample min/max - 1 thousand passes - 16000001 samples\n\n"); - /* generate random sample values */ - for (i = 0; i < 16000001; i++) - q[i] = rand(); - start = clock(); - for (i = 0; i < 1000; i++) { + for (i = 0; i < 100; i++) { min = INT32_MAX; max = INT32_MIN; test_benchmark_sample_minmax_vec_impl(q, 16000001u, &min, &max); @@ -29,7 +25,7 @@ printf("- vec: took %f secs\n", (double)(end - start) / CLOCKS_PER_SEC); start = clock(); - for (i = 0; i < 1000; i++) { + for (i = 0; i < 100; i++) { min = INT32_MAX; max = INT32_MIN; test_benchmark_sample_minmax_simple_impl(q, 16000001u, &min, &max);
--- a/test/test_benchmark_vec.c Sun Apr 27 02:49:53 2025 -0400 +++ b/test/test_benchmark_vec.c Mon Apr 28 16:31:59 2025 -0400 @@ -6,31 +6,31 @@ int32_t smin = INT32_MAX, smax = INT32_MIN; uint32_t len32; int i; - vint16x32 min = vint16x32_splat(*pmin); - vint16x32 max = vint16x32_splat(*pmax); - VINT16x32_ALIGNED_ARRAY(mins); - VINT16x32_ALIGNED_ARRAY(maxs); + vint16x8 min = vint16x8_splat(*pmin); + vint16x8 max = vint16x8_splat(*pmax); + VINT16x8_ALIGNED_ARRAY(mins); + VINT16x8_ALIGNED_ARRAY(maxs); - len32 = length / 32; + len32 = length / 8; while (len32--) { - vint16x32 vec = vint16x32_load_aligned(smpl); + vint16x8 vec = vint16x8_load_aligned(smpl); - min = vint16x32_min(vec, min); - max = vint16x32_max(vec, max); + min = vint16x8_min(vec, min); + max = vint16x8_max(vec, max); - smpl += 32; + smpl += 8; } - vint16x32_store_aligned(min, mins); - vint16x32_store_aligned(max, maxs); + vint16x8_store_aligned(min, mins); + vint16x8_store_aligned(max, maxs); /* get the lowest minimum of what we have left */ - for (i = 0; i < 32; i++) { + for (i = 0; i < 8; i++) { if (mins[i] < smin) smin = mins[i]; if (maxs[i] > smax) smax = maxs[i]; } - len32 = length % 32; + len32 = length % 8; while (len32--) { if (*smpl < smin) smin = *smpl; if (*smpl > smax) smax = *smpl;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/utils/genaltivec.c Mon Apr 28 16:31:59 2025 -0400 @@ -0,0 +1,374 @@ +/** + * vec - a tiny SIMD vector library in C99 + * + * Copyright (c) 2024-2025 Paper + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. +**/ + +/* Use this file to generate include/vec/impl/ppc/altivec.h !! + * + * `gcc -o genaltivec genaltivec.c` */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> + +#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) + +/* ------------------------------------------------------------------------ */ + +/* #define USE_VSX_EXTENSIONS */ + +enum op { + /* return vector, take in a integer */ + OP_SPLAT = 0, + + /* return vector, take in an array */ + OP_LOAD_ALIGNED, + OP_LOAD, + + /* void, take in vector and array */ + OP_STORE_ALIGNED, + OP_STORE, + + /* return vector, takes in two vectors */ + OP_ADD, + OP_SUB, + OP_MUL, + OP_AND, + OP_OR, + OP_XOR, + OP_CMPLT, + OP_CMPEQ, + OP_CMPGT, +#ifdef USE_VSX_EXTENSIONS + OP_CMPLE, + OP_CMPGE, +#endif + OP_MIN, + OP_MAX, + OP_AVG, + + /* return vector, takes in a vector and an explicitly unsigned vector */ + OP_LSHIFT, + OP_LRSHIFT, + OP_RSHIFT, + + OP_FINAL_, + + /* unimplemented, no altivec version :) */ + OP_NOT, +}; + +/* convert op -> string */ +static struct { + const char *u; + const char *l; +} op_names[] = { + [OP_SPLAT] = {"SPLAT", "splat"}, + [OP_LOAD_ALIGNED] = {"LOAD_ALIGNED", "load_aligned"}, + [OP_LOAD] = {"LOAD", "load"}, + [OP_STORE_ALIGNED] = {"STORE_ALIGNED", "store_aligned"}, + [OP_STORE] = {"STORE", "store"}, + [OP_ADD] = {"ADD", "add"}, + [OP_SUB] = {"SUB", "sub"}, + [OP_MUL] = {"MUL", "mul"}, + [OP_AVG] = {"AVG", "avg"}, + [OP_AND] = {"AND", "and"}, + [OP_OR] = {"OR", "or"}, + [OP_XOR] = {"XOR", "xor"}, + [OP_NOT] = {"NOT", "not"}, + [OP_CMPLT] = {"CMPLT", "cmplt"}, + [OP_CMPEQ] = {"CMPEQ", "cmpeq"}, + [OP_CMPGT] = {"CMPGT", "cmpgt"}, +#ifdef USE_VSX_EXTENSIONS + [OP_CMPLE] = {"CMPLE", "cmple"}, + [OP_CMPGE] = {"CMPGE", "cmpge"}, +#endif + [OP_MIN] = {"MIN", "min"}, + [OP_MAX] = {"MAX", "max"}, + [OP_RSHIFT] = {"RSHIFT", "rshift"}, + [OP_LRSHIFT] = {"LRSHIFT", "lrshift"}, + [OP_LSHIFT] = {"LSHIFT", "lshift"}, +}; + +#define UPSIGN(x) ((x) ? "" : "U") +#define LOSIGN(x) ((x) ? "" : "u") + +static void print_gcc_op(enum op op, int is_signed, int bits, int size) +{ + int i; + + /* compatibility with ancient gcc */ + switch (op) { + case OP_MUL: + puts("#ifdef vec_mul"); + break; + case OP_SPLAT: + puts("#ifdef vec_splats"); + break; + default: + break; + } + + printf("#ifndef V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u); + + printf("VEC_FUNC_IMPL "); + + /* first; the return value */ + switch (op) { + case OP_SPLAT: + case OP_LOAD_ALIGNED: + case OP_LOAD: + case OP_ADD: + case OP_SUB: + case OP_MUL: + case OP_AND: + case OP_OR: + case OP_XOR: + case OP_CMPLT: + case OP_CMPEQ: + case OP_CMPGT: +#ifdef USE_VSX_EXTENSIONS + case OP_CMPLE: + case OP_CMPGE: +#endif + case OP_MIN: + case OP_MAX: + case OP_AVG: + case OP_RSHIFT: + case OP_LRSHIFT: + case OP_LSHIFT: + case OP_NOT: + printf("v%sint%dx%d", LOSIGN(is_signed), bits, size); + break; + case OP_STORE_ALIGNED: + case OP_STORE: + printf("void"); + break; + } + + /* whitespace and function name */ + printf(" v%sint%dx%d_%s(", LOSIGN(is_signed), bits, size, op_names[op].l); + + /* parameters */ + switch (op) { + case OP_SPLAT: + printf("vec_%sint%d x", LOSIGN(is_signed), bits); + break; + case OP_LOAD_ALIGNED: + case OP_LOAD: + printf("const vec_%sint%d x[%d]", LOSIGN(is_signed), bits, size); + break; + case OP_STORE_ALIGNED: + case OP_STORE: + printf("v%sint%dx%d vec, vec_%sint%d arr[%d]", LOSIGN(is_signed), bits, size, LOSIGN(is_signed), bits, size); + break; + case OP_ADD: + case OP_SUB: + case OP_MUL: + case OP_AND: + case OP_OR: + case OP_XOR: + case OP_CMPLT: + case OP_CMPEQ: + case OP_CMPGT: +#ifdef USE_VSX_EXTENSIONS + case OP_CMPLE: + case OP_CMPGE: +#endif + case OP_MIN: + case OP_MAX: + case OP_AVG: + printf("v%sint%dx%d vec1, v%sint%dx%d vec2", LOSIGN(is_signed), bits, size, LOSIGN(is_signed), bits, size); + break; + case OP_RSHIFT: + case OP_LRSHIFT: + case OP_LSHIFT: + printf("v%sint%dx%d vec1, vuint%dx%d vec2", LOSIGN(is_signed), bits, size, bits, size); + break; + case OP_NOT: + printf("v%sint%dx%d vec", LOSIGN(is_signed), bits, size); + break; + } + + puts(")\n{"); + + switch (op) { + case OP_SPLAT: + printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size); + printf("\tvec.altivec = vec_splats(x);\n"); + printf("\treturn vec;\n"); + break; + case OP_LOAD_ALIGNED: + printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size); + puts("\tvec.altivec = vec_ld(0, x);"); + printf("\treturn vec;\n"); + break; + case OP_LOAD: + printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size); + puts("\tvec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));"); + printf("\treturn vec;\n"); + break; + case OP_STORE_ALIGNED: + puts("\tvec_st(vec.altivec, 0, arr);"); + break; + case OP_STORE: + /* ??? */ + puts("\tmemcpy(arr, &vec, sizeof(vec));"); + break; + case OP_ADD: + case OP_SUB: + case OP_MUL: + case OP_AND: + case OP_OR: + case OP_XOR: + case OP_AVG: + case OP_CMPLT: + case OP_CMPEQ: + case OP_CMPGT: +#ifdef USE_VSX_EXTENSIONS + case OP_CMPLE: + case OP_CMPGE: +#endif + case OP_LSHIFT: + case OP_LRSHIFT: + case OP_RSHIFT: + case OP_MIN: + case OP_MAX: { + static const char *op_altivec[OP_LRSHIFT - OP_ADD + 1] = {"add", "sub", "mul", "and", "or", "xor", "cmplt", "cmpeq", "cmpgt", +#ifdef USE_VSX_EXTENSIONS + "cmple", + "cmpge", +#endif + "min", "max", "avg", "sl", "sr"}; + static const char *types[] = {"char", "short", NULL, "int"}; + + printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size); + if (op == OP_RSHIFT) { + printf("\tvec.altivec = vec_sr%s(vec1.altivec, vec2.altivec);\n", (is_signed) ? "a" : ""); + } else { + printf("\tvec.altivec = (vector %s %s)vec_%s(vec1.altivec, vec2.altivec);\n", (is_signed) ? "signed" : "unsigned", types[(bits / 8) - 1], op_altivec[op - OP_ADD]); + } + printf("\treturn vec;\n"); + break; + } + default: + printf("#error implement this operation"); + break; + } + + /* end function definition */ + puts("}"); + + printf("# define V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u); + puts("#endif"); + + switch (op) { + case OP_SPLAT: + case OP_MUL: + puts("#endif"); + break; + default: + break; + } +} + +static inline void print_ops(int is_signed, int bits, int size) +{ + int i; + + printf("\n\n/* v%sint%dx%d */\n\n", (is_signed ? "u" : ""), bits, size); + + for (i = 0; i < OP_FINAL_; i++) + print_gcc_op(i, is_signed, bits, size); +} + +#ifdef USE_VSX_EXTENSIONS +# define HEADER_GUARD_NAME "VSX" +#else +# define HEADER_GUARD_NAME "ALTIVEC" +#endif + +static const char *header = + "/**\n" + " * vec - a tiny SIMD vector library in C99\n" + " * \n" + " * Copyright (c) 2024-2025 Paper\n" + " * \n" + " * Permission is hereby granted, free of charge, to any person obtaining a copy\n" + " * of this software and associated documentation files (the \"Software\"), to deal\n" + " * in the Software without restriction, including without limitation the rights\n" + " * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n" + " * copies of the Software, and to permit persons to whom the Software is\n" + " * furnished to do so, subject to the following conditions:\n" + " * \n" + " * The above copyright notice and this permission notice shall be included in all\n" + " * copies or substantial portions of the Software.\n" + " * \n" + " * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n" + " * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n" + " * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n" + " * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n" + " * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n" + " * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n" + " * SOFTWARE.\n" + "**/\n" + "\n" + "/* This file is automatically generated! Do not edit it directly!\n" + " * Edit the code that generates it in utils/genaltivec.c --paper */\n" + "\n" + "#ifndef VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_\n" + "#define VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_\n" + "\n"; + +static const char *footer = + "#endif /* VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_ */\n"; + +int main(void) +{ + static struct { + int bits, size; + } defs[] = { + /* -- 8-bit */ + {8, 16}, + /* -- 16-bit */ + {16, 8}, + + /* -- 32-bit */ + {32, 4}, + +#ifdef USE_VSX_EXTENSIONS + /* -- 64-bit */ + {64, 2}, +#endif + }; + int i; + + puts(header); + + for (i = 0; i < ARRAY_SIZE(defs); i++) { + print_ops(1, defs[i].bits, defs[i].size); + print_ops(0, defs[i].bits, defs[i].size); + } + + puts(footer); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/utils/gendouble.c Mon Apr 28 16:31:59 2025 -0400 @@ -0,0 +1,244 @@ +/** + * vec - a tiny SIMD vector library in C99 + * + * Copyright (c) 2024-2025 Paper + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. +**/ + +/* Use this file to generate include/vec/impl/double.h !! + * + * `gcc -o gendouble gendouble.c` */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> + +#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) + +/* XXX: would it be faster to unroll literally everything instead of defining everything, + * and then unpacking it all? */ +static const char *header = + "/**\n" + " * vec - a tiny SIMD vector library in C99\n" + " * \n" + " * Copyright (c) 2024-2025 Paper\n" + " * \n" + " * Permission is hereby granted, free of charge, to any person obtaining a copy\n" + " * of this software and associated documentation files (the \"Software\"), to deal\n" + " * in the Software without restriction, including without limitation the rights\n" + " * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n" + " * copies of the Software, and to permit persons to whom the Software is\n" + " * furnished to do so, subject to the following conditions:\n" + " * \n" + " * The above copyright notice and this permission notice shall be included in all\n" + " * copies or substantial portions of the Software.\n" + " * \n" + " * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n" + " * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n" + " * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n" + " * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n" + " * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n" + " * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n" + " * SOFTWARE.\n" + "**/\n" + "\n" + "/* This file is automatically generated! Do not edit it directly!\n" + " * Edit the code that generates it in utils/gengeneric.c --paper */\n" + "\n" + "#ifndef VEC_IMPL_DOUBLE_H_\n" + "#define VEC_IMPL_DOUBLE_H_\n" + "\n" + "#define VEC_DOUBLE_SPLAT(sign, bits, size, halfsize) \\\n" + " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \\\n" + " { \\\n" + " v##sign##int##bits##x##size vec; \\\n" + " \\\n" + " vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \\\n" + " vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \\\n" + " \\\n" + " return vec; \\\n" + " }\n" + "\n" + "#define VEC_DOUBLE_LOAD_EX(name, sign, bits, size, halfsize) \\\n" + " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \\\n" + " { \\\n" + " v##sign##int##bits##x##size vec; \\\n" + " \\\n" + " vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \\\n" + " vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \\\n" + " \\\n" + " return vec; \\\n" + " }\n" + "\n" + "#define VEC_DOUBLE_LOAD(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load, sign, bits, size, halfsize)\n" + "#define VEC_DOUBLE_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load_aligned, sign, bits, size, halfsize)\n" + "\n" + "#define VEC_DOUBLE_STORE_EX(name, sign, bits, size, halfsize) \\\n" + " VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \\\n" + " { \\\n" + " v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \\\n" + " v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \\\n" + " }\n" + "\n" + "#define VEC_DOUBLE_STORE(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store, sign, bits, size, halfsize)\n" + "#define VEC_DOUBLE_STORE_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store_aligned, sign, bits, size, halfsize)\n" + "\n" + "#define VEC_DOUBLE_OP(name, sign, bits, size, halfsize, secondsign) \\\n" + " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \\\n" + " { \\\n" + " vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \\\n" + " vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \\\n" + " \\\n" + " return vec1; \\\n" + " }\n" + "\n" + "#define VEC_DOUBLE_ADD(sign, bits, size, halfsize) VEC_DOUBLE_OP(add, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_SUB(sign, bits, size, halfsize) VEC_DOUBLE_OP(sub, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_MUL(sign, bits, size, halfsize) VEC_DOUBLE_OP(mul, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_DIV(sign, bits, size, halfsize) VEC_DOUBLE_OP(div, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_MOD(sign, bits, size, halfsize) VEC_DOUBLE_OP(mod, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_AVG(sign, bits, size, halfsize) VEC_DOUBLE_OP(avg, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_LSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lshift, sign, bits, size, halfsize, u)\n" + "#define VEC_DOUBLE_RSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(rshift, sign, bits, size, halfsize, u)\n" + "#define VEC_DOUBLE_LRSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lrshift, sign, bits, size, halfsize, u)\n" + "#define VEC_DOUBLE_AND(sign, bits, size, halfsize) VEC_DOUBLE_OP(and, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_OR(sign, bits, size, halfsize) VEC_DOUBLE_OP(or, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_XOR(sign, bits, size, halfsize) VEC_DOUBLE_OP(xor, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_MIN(sign, bits, size, halfsize) VEC_DOUBLE_OP(min, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_MAX(sign, bits, size, halfsize) VEC_DOUBLE_OP(max, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_CMPLT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmplt, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_CMPLE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmple, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_CMPEQ(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpeq, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_CMPGE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpge, sign, bits, size, halfsize, sign)\n" + "#define VEC_DOUBLE_CMPGT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpgt, sign, bits, size, halfsize, sign)\n" + "\n" + "#define VEC_DOUBLE_NOT(sign, bits, size, halfsize) \\\n" + " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \\\n" + " { \\\n" + " vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \\\n" + " vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \\\n" + " \\\n" + " return vec; \\\n" + " }\n" + "\n" + "#endif /* VEC_IMPL_DOUBLE_H_ */ \n" + "\n" + "/* ------------------------------------------------------------------------ */\n" + "/* PREPROCESSOR HELL INCOMING */\n" + ""; + +static const char *footer = + "" /* nothing */; + +/* ------------------------------------------------------------------------ */ + +static void print_generic_dbl_op(const char *op, int is_signed, int bits, int size) +{ + printf( + "#if !defined(V%sINT%dx%d_%s_DEFINED) && defined(V%sINT%dx%d_%s_DEFINED)\n" + "VEC_DOUBLE_%s(%s, %d, %d, %d)\n" + "# define V%sINT%dx%d_%s_DEFINED\n" + "#endif\n\n", + (is_signed ? "" : "U"), bits, size, op, (is_signed ? "" : "U"), bits, size / 2, op, + op, (is_signed ? "/* nothing */" : "u"), bits, size, size / 2, + (is_signed ? "" : "U"), bits, size, op); +} + +typedef void (*print_op_spec)(const char *op, int is_signed, int bits, int size); + +static inline void print_ops(int is_signed, int bits, int size, print_op_spec print_op) +{ + /* all supported operations here */ + static const char *ops[] = { + "SPLAT", + "LOAD_ALIGNED", + "LOAD", + "STORE_ALIGNED", + "STORE", + "ADD", + "SUB", + "MUL", + "DIV", + "MOD", + "AVG", + "AND", + "OR", + "XOR", + "NOT", + "CMPLT", + "CMPEQ", + "CMPGT", + "CMPLE", /* these two must be after CMPLT and CMPGT respectfully, */ + "CMPGE", /* because their definitions call those functions */ + "MIN", + "MAX", + "RSHIFT", + "LRSHIFT", + "LSHIFT", + NULL, + }; + int i; + + printf("\n\n/* v%sint%dx%d */\n\n", (is_signed ? "u" : ""), bits, size); + + for (i = 0; ops[i]; i++) + print_op(ops[i], is_signed, bits, size); +} + +int main(void) +{ + static struct { + int bits, size; + print_op_spec print_op; + } defs[] = { + /* -- 8-bit */ + {8, 4, print_generic_dbl_op}, + {8, 8, print_generic_dbl_op}, + {8, 16, print_generic_dbl_op}, + {8, 32, print_generic_dbl_op}, + {8, 64, print_generic_dbl_op}, + + /* -- 16-bit */ + {16, 4, print_generic_dbl_op}, + {16, 8, print_generic_dbl_op}, + {16, 16, print_generic_dbl_op}, + {16, 32, print_generic_dbl_op}, + + /* -- 32-bit */ + {32, 4, print_generic_dbl_op}, + {32, 8, print_generic_dbl_op}, + {32, 16, print_generic_dbl_op}, + + /* -- 64-bit */ + {64, 4, print_generic_dbl_op}, + {64, 8, print_generic_dbl_op}, + }; + int i; + + puts(header); + + for (i = 0; i < ARRAY_SIZE(defs); i++) { + print_ops(1, defs[i].bits, defs[i].size, defs[i].print_op); + print_ops(0, defs[i].bits, defs[i].size, defs[i].print_op); + } + + puts(footer); +}
--- a/utils/gengcc.c Sun Apr 27 02:49:53 2025 -0400 +++ b/utils/gengcc.c Mon Apr 28 16:31:59 2025 -0400 @@ -119,7 +119,27 @@ static void print_gcc_op(enum op op, int is_signed, int bits, int size) { int i; + int gccprereq = 0; + switch (op) { + case OP_CMPEQ: + case OP_CMPLE: + case OP_CMPLT: + case OP_CMPGT: + case OP_CMPGE: + case OP_MIN: + case OP_MAX: + case OP_LSHIFT: + case OP_RSHIFT: + case OP_LRSHIFT: + case OP_AVG: + puts("#if VEC_GNUC_ATLEAST(4, 3, 0)"); + gccprereq = 1; + break; + default: + break; + } + printf("#ifndef V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u); printf("VEC_FUNC_IMPL "); @@ -271,16 +291,17 @@ break; } case OP_AVG: + printf("\tvint%dx%d ones = vint%dx%d_splat(1);\n", bits, size, bits, size); + if (is_signed) { - printf("\tvint%dx%d ones = vint%dx%d_splat(1);\n", bits, size, bits, size); - printf("\t__typeof__(vec1.gcc) x_d_rem = (vec1.gcc % 2);\n"); - printf("\t__typeof__(vec1.gcc) y_d_rem = (vec2.gcc % 2);\n"); - printf("\t__typeof__(vec1.gcc) rem_d_quot = ((x_d_rem + y_d_rem) / 2);\n"); - printf("\t__typeof__(vec1.gcc) rem_d_rem = ((x_d_rem + y_d_rem) % 2);\n"); + puts("\t__typeof__(vec1.gcc) x_d_rem = (vec1.gcc % 2);"); + puts("\t__typeof__(vec1.gcc) y_d_rem = (vec2.gcc % 2);"); + puts("\t__typeof__(vec1.gcc) rem_d_quot = ((x_d_rem + y_d_rem) / 2);"); + puts("\t__typeof__(vec1.gcc) rem_d_rem = ((x_d_rem + y_d_rem) % 2);"); puts(""); printf("\tvec1.gcc = ((vec1.gcc / 2) + (vec2.gcc / 2)) + (rem_d_quot) + ((rem_d_rem == 1) & ones.gcc);\n"); } else { - printf("\tvec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);\n"); + printf("\tvec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);\n"); } printf("\treturn vec1;\n"); @@ -299,6 +320,9 @@ printf("# define V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u); puts("#endif"); + + if (gccprereq) + puts("#endif"); } static inline void print_ops(int is_signed, int bits, int size)
--- a/utils/gengeneric.c Sun Apr 27 02:49:53 2025 -0400 +++ b/utils/gengeneric.c Mon Apr 28 16:31:59 2025 -0400 @@ -147,7 +147,7 @@ " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \\\n" " { \\\n" " for (int i = 0; i < size; i++) \\\n" - " vec1.generic[i] = vec_##sign##avg(vec1.generic[i], vec2.generic[i]); \\\n" + " vec1.generic[i] = vec_im##sign##avg(vec1.generic[i], vec2.generic[i]); \\\n" " \\\n" " return vec1; \\\n" " }\n" @@ -246,79 +246,6 @@ " return v##sign##int##bits##x##size##_or(a, b); \\\n" " }\n" "\n" - "#define VEC_GENERIC_DBL_SPLAT(sign, bits, size, halfsize) \\\n" - " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \\\n" - " { \\\n" - " v##sign##int##bits##x##size vec; \\\n" - " \\\n" - " vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \\\n" - " vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \\\n" - " \\\n" - " return vec; \\\n" - " }\n" - "\n" - "#define VEC_GENERIC_DBL_LOAD_EX(name, sign, bits, size, halfsize) \\\n" - " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \\\n" - " { \\\n" - " v##sign##int##bits##x##size vec; \\\n" - " \\\n" - " vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \\\n" - " vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \\\n" - " \\\n" - " return vec; \\\n" - " }\n" - "\n" - "#define VEC_GENERIC_DBL_LOAD(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load, sign, bits, size, halfsize)\n" - "#define VEC_GENERIC_DBL_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load_aligned, sign, bits, size, halfsize)\n" - "\n" - "#define VEC_GENERIC_DBL_STORE_EX(name, sign, bits, size, halfsize) \\\n" - " VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \\\n" - " { \\\n" - " v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \\\n" - " v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \\\n" - " }\n" - "\n" - "#define VEC_GENERIC_DBL_STORE(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store, sign, bits, size, halfsize)\n" - "#define VEC_GENERIC_DBL_STORE_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store_aligned, sign, bits, size, halfsize)\n" - "\n" - "#define VEC_GENERIC_DBL_OP(name, sign, bits, size, halfsize, secondsign) \\\n" - " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \\\n" - " { \\\n" - " vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \\\n" - " vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \\\n" - " \\\n" - " return vec1; \\\n" - " }\n" - "\n" - "#define VEC_GENERIC_DBL_ADD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(add, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_SUB(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(sub, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_MUL(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mul, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_DIV(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(div, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_MOD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mod, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_AVG(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(avg, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_LSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lshift, sign, bits, size, halfsize, u)\n" - "#define VEC_GENERIC_DBL_RSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(rshift, sign, bits, size, halfsize, u)\n" - "#define VEC_GENERIC_DBL_LRSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lrshift, sign, bits, size, halfsize, u)\n" - "#define VEC_GENERIC_DBL_AND(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(and, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_OR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(or, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_XOR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(xor, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_MIN(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(min, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_MAX(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(max, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_CMPLT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmplt, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_CMPLE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmple, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_CMPEQ(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpeq, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_CMPGE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpge, sign, bits, size, halfsize, sign)\n" - "#define VEC_GENERIC_DBL_CMPGT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpgt, sign, bits, size, halfsize, sign)\n" - "\n" - "#define VEC_GENERIC_DBL_NOT(sign, bits, size, halfsize) \\\n" - " VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \\\n" - " { \\\n" - " vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \\\n" - " vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \\\n" - " \\\n" - " return vec; \\\n" - " }\n" - "\n" "/* ------------------------------------------------------------------------ */\n" "/* PREPROCESSOR HELL INCOMING */\n"; @@ -337,16 +264,6 @@ (is_signed ? "" : "U"), bits, size, op, op, (is_signed ? "/* nothing */" : "u"), bits, size, (is_signed ? "" : "U"), bits, size, op); } -static void print_generic_dbl_op(const char *op, int is_signed, int bits, int size) -{ - printf( - "#ifndef V%sINT%dx%d_%s_DEFINED\n" - "VEC_GENERIC_DBL_%s(%s, %d, %d, %d)\n" - "# define V%sINT%dx%d_%s_DEFINED\n" - "#endif\n\n", - (is_signed ? "" : "U"), bits, size, op, op, (is_signed ? "/* nothing */" : "u"), bits, size, size / 2, (is_signed ? "" : "U"), bits, size, op); -} - typedef void (*print_op_spec)(const char *op, int is_signed, int bits, int size); static inline void print_ops(int is_signed, int bits, int size, print_op_spec print_op) @@ -396,29 +313,15 @@ } defs[] = { /* -- 8-bit */ {8, 2, print_generic_op}, - {8, 4, print_generic_dbl_op}, - {8, 8, print_generic_dbl_op}, - {8, 16, print_generic_dbl_op}, - {8, 32, print_generic_dbl_op}, - {8, 64, print_generic_dbl_op}, /* -- 16-bit */ {16, 2, print_generic_op}, - {16, 4, print_generic_dbl_op}, - {16, 8, print_generic_dbl_op}, - {16, 16, print_generic_dbl_op}, - {16, 32, print_generic_dbl_op}, /* -- 32-bit */ {32, 2, print_generic_op}, - {32, 4, print_generic_dbl_op}, - {32, 8, print_generic_dbl_op}, - {32, 16, print_generic_dbl_op}, /* -- 64-bit */ {64, 2, print_generic_op}, - {64, 4, print_generic_dbl_op}, - {64, 8, print_generic_dbl_op}, }; int i;