| /* |
| * Copyright (c) 2014 Advanced Micro Devices, Inc. |
| * |
| * 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. |
| */ |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float2 |
| vload2(size_t i, const float *p) |
| { |
| return as_float2(vload2(i, (const int *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float2 |
| vload2(size_t i, const __constant float *p) |
| { |
| return as_float2(vload2(i, (const __constant int *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float2 |
| vload2(size_t i, const __global float *p) |
| { |
| return as_float2(vload2(i, (const __global int *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float2 |
| vload2(size_t i, const __local float *p) |
| { |
| return as_float2(vload2(i, (const __local int *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double2 |
| vload2(size_t i, const double *p) |
| { |
| return as_double2(vload2(i, (const long *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double2 |
| vload2(size_t i, const __constant double *p) |
| { |
| return as_double2(vload2(i, (const __constant long *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double2 |
| vload2(size_t i, const __global double *p) |
| { |
| return as_double2(vload2(i, (const __global long *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double2 |
| vload2(size_t i, const __local double *p) |
| { |
| return as_double2(vload2(i, (const __local long *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float3 |
| vload3(size_t i, const float *p) |
| { |
| return as_float3(vload3(i, (const int *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float3 |
| vload3(size_t i, const __constant float *p) |
| { |
| return as_float3(vload3(i, (const __constant int *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float3 |
| vload3(size_t i, const __global float *p) |
| { |
| return as_float3(vload3(i, (const __global int *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float3 |
| vload3(size_t i, const __local float *p) |
| { |
| return as_float3(vload3(i, (const __local int *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double3 |
| vload3(size_t i, const double *p) |
| { |
| return as_double3(vload3(i, (const long *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double3 |
| vload3(size_t i, const __constant double *p) |
| { |
| return as_double3(vload3(i, (const __constant long *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double3 |
| vload3(size_t i, const __global double *p) |
| { |
| return as_double3(vload3(i, (const __global long *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double3 |
| vload3(size_t i, const __local double *p) |
| { |
| return as_double3(vload3(i, (const __local long *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float4 |
| vload4(size_t i, const float *p) |
| { |
| return as_float4(vload4(i, (const int *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float4 |
| vload4(size_t i, const __constant float *p) |
| { |
| return as_float4(vload4(i, (const __constant int *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float4 |
| vload4(size_t i, const __global float *p) |
| { |
| return as_float4(vload4(i, (const __global int *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float4 |
| vload4(size_t i, const __local float *p) |
| { |
| return as_float4(vload4(i, (const __local int *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double4 |
| vload4(size_t i, const double *p) |
| { |
| return as_double4(vload4(i, (const long *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double4 |
| vload4(size_t i, const __constant double *p) |
| { |
| return as_double4(vload4(i, (const __constant long *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double4 |
| vload4(size_t i, const __global double *p) |
| { |
| return as_double4(vload4(i, (const __global long *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double4 |
| vload4(size_t i, const __local double *p) |
| { |
| return as_double4(vload4(i, (const __local long *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float8 |
| vload8(size_t i, const float *p) |
| { |
| return as_float8(vload8(i, (const int *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float8 |
| vload8(size_t i, const __constant float *p) |
| { |
| return as_float8(vload8(i, (const __constant int *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float8 |
| vload8(size_t i, const __global float *p) |
| { |
| return as_float8(vload8(i, (const __global int *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float8 |
| vload8(size_t i, const __local float *p) |
| { |
| return as_float8(vload8(i, (const __local int *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double8 |
| vload8(size_t i, const double *p) |
| { |
| return as_double8(vload8(i, (const long *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double8 |
| vload8(size_t i, const __constant double *p) |
| { |
| return as_double8(vload8(i, (const __constant long *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double8 |
| vload8(size_t i, const __global double *p) |
| { |
| return as_double8(vload8(i, (const __global long *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double8 |
| vload8(size_t i, const __local double *p) |
| { |
| return as_double8(vload8(i, (const __local long *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float16 |
| vload16(size_t i, const float *p) |
| { |
| return as_float16(vload16(i, (const int *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) float16 |
| vload16(size_t i, const __constant float *p) |
| { |
| return as_float16(vload16(i, (const __constant int *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float16 |
| vload16(size_t i, const __global float *p) |
| { |
| return as_float16(vload16(i, (const __global int *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) float16 |
| vload16(size_t i, const __local float *p) |
| { |
| return as_float16(vload16(i, (const __local int *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double16 |
| vload16(size_t i, const double *p) |
| { |
| return as_double16(vload16(i, (const long *)p)); |
| } |
| |
| |
| |
| __attribute__((overloadable, always_inline, weak)) double16 |
| vload16(size_t i, const __constant double *p) |
| { |
| return as_double16(vload16(i, (const __constant long *)p)); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double16 |
| vload16(size_t i, const __global double *p) |
| { |
| return as_double16(vload16(i, (const __global long *)p)); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) double16 |
| vload16(size_t i, const __local double *p) |
| { |
| return as_double16(vload16(i, (const __local long *)p)); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(float2 v, size_t i, float *p) |
| { |
| vstore2(as_int2(v), i, (int *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(float2 v, size_t i, __global float *p) |
| { |
| vstore2(as_int2(v), i, (__global int *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(float2 v, size_t i, __local float *p) |
| { |
| vstore2(as_int2(v), i, (__local int *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(double2 v, size_t i, double *p) |
| { |
| vstore2(as_long2(v), i, (long *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(double2 v, size_t i, __global double *p) |
| { |
| vstore2(as_long2(v), i, (__global long *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore2(double2 v, size_t i, __local double *p) |
| { |
| vstore2(as_long2(v), i, (__local long *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(float3 v, size_t i, float *p) |
| { |
| vstore3(as_int3(v), i, (int *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(float3 v, size_t i, __global float *p) |
| { |
| vstore3(as_int3(v), i, (__global int *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(float3 v, size_t i, __local float *p) |
| { |
| vstore3(as_int3(v), i, (__local int *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(double3 v, size_t i, double *p) |
| { |
| vstore3(as_long3(v), i, (long *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(double3 v, size_t i, __global double *p) |
| { |
| vstore3(as_long3(v), i, (__global long *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore3(double3 v, size_t i, __local double *p) |
| { |
| vstore3(as_long3(v), i, (__local long *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(float4 v, size_t i, float *p) |
| { |
| vstore4(as_int4(v), i, (int *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(float4 v, size_t i, __global float *p) |
| { |
| vstore4(as_int4(v), i, (__global int *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(float4 v, size_t i, __local float *p) |
| { |
| vstore4(as_int4(v), i, (__local int *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(double4 v, size_t i, double *p) |
| { |
| vstore4(as_long4(v), i, (long *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(double4 v, size_t i, __global double *p) |
| { |
| vstore4(as_long4(v), i, (__global long *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore4(double4 v, size_t i, __local double *p) |
| { |
| vstore4(as_long4(v), i, (__local long *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(float8 v, size_t i, float *p) |
| { |
| vstore8(as_int8(v), i, (int *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(float8 v, size_t i, __global float *p) |
| { |
| vstore8(as_int8(v), i, (__global int *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(float8 v, size_t i, __local float *p) |
| { |
| vstore8(as_int8(v), i, (__local int *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(double8 v, size_t i, double *p) |
| { |
| vstore8(as_long8(v), i, (long *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(double8 v, size_t i, __global double *p) |
| { |
| vstore8(as_long8(v), i, (__global long *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore8(double8 v, size_t i, __local double *p) |
| { |
| vstore8(as_long8(v), i, (__local long *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(float16 v, size_t i, float *p) |
| { |
| vstore16(as_int16(v), i, (int *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(float16 v, size_t i, __global float *p) |
| { |
| vstore16(as_int16(v), i, (__global int *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(float16 v, size_t i, __local float *p) |
| { |
| vstore16(as_int16(v), i, (__local int *)p); |
| } |
| #endif |
| |
| |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(double16 v, size_t i, double *p) |
| { |
| vstore16(as_long16(v), i, (long *)p); |
| } |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(double16 v, size_t i, __global double *p) |
| { |
| vstore16(as_long16(v), i, (__global long *)p); |
| } |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((overloadable, always_inline, weak)) void |
| vstore16(double16 v, size_t i, __local double *p) |
| { |
| vstore16(as_long16(v), i, (__local long *)p); |
| } |
| #endif |
| |
| |
| __attribute__((always_inline)) static char2 |
| vldp12(size_t i, const char *p) |
| { |
| char2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp12"))) char2 vload2(size_t, const char *); |
| extern __attribute__((overloadable, weak, alias("vldp12"))) uchar2 vload2(size_t, const uchar *); |
| |
| |
| |
| __attribute__((always_inline)) static char2 |
| vldc12(size_t i, const __constant char *p) |
| { |
| char2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc12"))) char2 vload2(size_t, const __constant char *); |
| extern __attribute__((overloadable, weak, alias("vldc12"))) uchar2 vload2(size_t, const __constant uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char2 |
| vldg12(size_t i, const __global char *p) |
| { |
| char2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg12"))) char2 vload2(size_t, const __global char *); |
| extern __attribute__((overloadable, weak, alias("vldg12"))) uchar2 vload2(size_t, const __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char2 |
| vldl12(size_t i, const __local char *p) |
| { |
| char2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl12"))) char2 vload2(size_t, const __local char *); |
| extern __attribute__((overloadable, weak, alias("vldl12"))) uchar2 vload2(size_t, const __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static short2 |
| vldp22(size_t i, const short *p) |
| { |
| short2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp22"))) short2 vload2(size_t, const short *); |
| extern __attribute__((overloadable, weak, alias("vldp22"))) ushort2 vload2(size_t, const ushort *); |
| |
| |
| |
| __attribute__((always_inline)) static short2 |
| vldc22(size_t i, const __constant short *p) |
| { |
| short2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc22"))) short2 vload2(size_t, const __constant short *); |
| extern __attribute__((overloadable, weak, alias("vldc22"))) ushort2 vload2(size_t, const __constant ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short2 |
| vldg22(size_t i, const __global short *p) |
| { |
| short2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg22"))) short2 vload2(size_t, const __global short *); |
| extern __attribute__((overloadable, weak, alias("vldg22"))) ushort2 vload2(size_t, const __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short2 |
| vldl22(size_t i, const __local short *p) |
| { |
| short2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl22"))) short2 vload2(size_t, const __local short *); |
| extern __attribute__((overloadable, weak, alias("vldl22"))) ushort2 vload2(size_t, const __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static int2 |
| vldp42(size_t i, const int *p) |
| { |
| int2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp42"))) int2 vload2(size_t, const int *); |
| extern __attribute__((overloadable, weak, alias("vldp42"))) uint2 vload2(size_t, const uint *); |
| |
| |
| |
| __attribute__((always_inline)) static int2 |
| vldc42(size_t i, const __constant int *p) |
| { |
| int2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc42"))) int2 vload2(size_t, const __constant int *); |
| extern __attribute__((overloadable, weak, alias("vldc42"))) uint2 vload2(size_t, const __constant uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int2 |
| vldg42(size_t i, const __global int *p) |
| { |
| int2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg42"))) int2 vload2(size_t, const __global int *); |
| extern __attribute__((overloadable, weak, alias("vldg42"))) uint2 vload2(size_t, const __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int2 |
| vldl42(size_t i, const __local int *p) |
| { |
| int2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl42"))) int2 vload2(size_t, const __local int *); |
| extern __attribute__((overloadable, weak, alias("vldl42"))) uint2 vload2(size_t, const __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static long2 |
| vldp82(size_t i, const long *p) |
| { |
| long2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp82"))) long2 vload2(size_t, const long *); |
| extern __attribute__((overloadable, weak, alias("vldp82"))) ulong2 vload2(size_t, const ulong *); |
| |
| |
| |
| __attribute__((always_inline)) static long2 |
| vldc82(size_t i, const __constant long *p) |
| { |
| long2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc82"))) long2 vload2(size_t, const __constant long *); |
| extern __attribute__((overloadable, weak, alias("vldc82"))) ulong2 vload2(size_t, const __constant ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long2 |
| vldg82(size_t i, const __global long *p) |
| { |
| long2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg82"))) long2 vload2(size_t, const __global long *); |
| extern __attribute__((overloadable, weak, alias("vldg82"))) ulong2 vload2(size_t, const __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long2 |
| vldl82(size_t i, const __local long *p) |
| { |
| long2 ret; |
| p += i * 2; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl82"))) long2 vload2(size_t, const __local long *); |
| extern __attribute__((overloadable, weak, alias("vldl82"))) ulong2 vload2(size_t, const __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static char3 |
| vldp13(size_t i, const char *p) |
| { |
| char3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp13"))) char3 vload3(size_t, const char *); |
| extern __attribute__((overloadable, weak, alias("vldp13"))) uchar3 vload3(size_t, const uchar *); |
| |
| |
| |
| __attribute__((always_inline)) static char3 |
| vldc13(size_t i, const __constant char *p) |
| { |
| char3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc13"))) char3 vload3(size_t, const __constant char *); |
| extern __attribute__((overloadable, weak, alias("vldc13"))) uchar3 vload3(size_t, const __constant uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char3 |
| vldg13(size_t i, const __global char *p) |
| { |
| char3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg13"))) char3 vload3(size_t, const __global char *); |
| extern __attribute__((overloadable, weak, alias("vldg13"))) uchar3 vload3(size_t, const __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char3 |
| vldl13(size_t i, const __local char *p) |
| { |
| char3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl13"))) char3 vload3(size_t, const __local char *); |
| extern __attribute__((overloadable, weak, alias("vldl13"))) uchar3 vload3(size_t, const __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static short3 |
| vldp23(size_t i, const short *p) |
| { |
| short3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp23"))) short3 vload3(size_t, const short *); |
| extern __attribute__((overloadable, weak, alias("vldp23"))) ushort3 vload3(size_t, const ushort *); |
| |
| |
| |
| __attribute__((always_inline)) static short3 |
| vldc23(size_t i, const __constant short *p) |
| { |
| short3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc23"))) short3 vload3(size_t, const __constant short *); |
| extern __attribute__((overloadable, weak, alias("vldc23"))) ushort3 vload3(size_t, const __constant ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short3 |
| vldg23(size_t i, const __global short *p) |
| { |
| short3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg23"))) short3 vload3(size_t, const __global short *); |
| extern __attribute__((overloadable, weak, alias("vldg23"))) ushort3 vload3(size_t, const __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short3 |
| vldl23(size_t i, const __local short *p) |
| { |
| short3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl23"))) short3 vload3(size_t, const __local short *); |
| extern __attribute__((overloadable, weak, alias("vldl23"))) ushort3 vload3(size_t, const __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static int3 |
| vldp43(size_t i, const int *p) |
| { |
| int3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp43"))) int3 vload3(size_t, const int *); |
| extern __attribute__((overloadable, weak, alias("vldp43"))) uint3 vload3(size_t, const uint *); |
| |
| |
| |
| __attribute__((always_inline)) static int3 |
| vldc43(size_t i, const __constant int *p) |
| { |
| int3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc43"))) int3 vload3(size_t, const __constant int *); |
| extern __attribute__((overloadable, weak, alias("vldc43"))) uint3 vload3(size_t, const __constant uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int3 |
| vldg43(size_t i, const __global int *p) |
| { |
| int3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg43"))) int3 vload3(size_t, const __global int *); |
| extern __attribute__((overloadable, weak, alias("vldg43"))) uint3 vload3(size_t, const __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int3 |
| vldl43(size_t i, const __local int *p) |
| { |
| int3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl43"))) int3 vload3(size_t, const __local int *); |
| extern __attribute__((overloadable, weak, alias("vldl43"))) uint3 vload3(size_t, const __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static long3 |
| vldp83(size_t i, const long *p) |
| { |
| long3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp83"))) long3 vload3(size_t, const long *); |
| extern __attribute__((overloadable, weak, alias("vldp83"))) ulong3 vload3(size_t, const ulong *); |
| |
| |
| |
| __attribute__((always_inline)) static long3 |
| vldc83(size_t i, const __constant long *p) |
| { |
| long3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc83"))) long3 vload3(size_t, const __constant long *); |
| extern __attribute__((overloadable, weak, alias("vldc83"))) ulong3 vload3(size_t, const __constant ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long3 |
| vldg83(size_t i, const __global long *p) |
| { |
| long3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg83"))) long3 vload3(size_t, const __global long *); |
| extern __attribute__((overloadable, weak, alias("vldg83"))) ulong3 vload3(size_t, const __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long3 |
| vldl83(size_t i, const __local long *p) |
| { |
| long3 ret; |
| p += i * 3; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl83"))) long3 vload3(size_t, const __local long *); |
| extern __attribute__((overloadable, weak, alias("vldl83"))) ulong3 vload3(size_t, const __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static char4 |
| vldp14(size_t i, const char *p) |
| { |
| char4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp14"))) char4 vload4(size_t, const char *); |
| extern __attribute__((overloadable, weak, alias("vldp14"))) uchar4 vload4(size_t, const uchar *); |
| |
| |
| |
| __attribute__((always_inline)) static char4 |
| vldc14(size_t i, const __constant char *p) |
| { |
| char4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc14"))) char4 vload4(size_t, const __constant char *); |
| extern __attribute__((overloadable, weak, alias("vldc14"))) uchar4 vload4(size_t, const __constant uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char4 |
| vldg14(size_t i, const __global char *p) |
| { |
| char4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg14"))) char4 vload4(size_t, const __global char *); |
| extern __attribute__((overloadable, weak, alias("vldg14"))) uchar4 vload4(size_t, const __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char4 |
| vldl14(size_t i, const __local char *p) |
| { |
| char4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl14"))) char4 vload4(size_t, const __local char *); |
| extern __attribute__((overloadable, weak, alias("vldl14"))) uchar4 vload4(size_t, const __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static short4 |
| vldp24(size_t i, const short *p) |
| { |
| short4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp24"))) short4 vload4(size_t, const short *); |
| extern __attribute__((overloadable, weak, alias("vldp24"))) ushort4 vload4(size_t, const ushort *); |
| |
| |
| |
| __attribute__((always_inline)) static short4 |
| vldc24(size_t i, const __constant short *p) |
| { |
| short4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc24"))) short4 vload4(size_t, const __constant short *); |
| extern __attribute__((overloadable, weak, alias("vldc24"))) ushort4 vload4(size_t, const __constant ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short4 |
| vldg24(size_t i, const __global short *p) |
| { |
| short4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg24"))) short4 vload4(size_t, const __global short *); |
| extern __attribute__((overloadable, weak, alias("vldg24"))) ushort4 vload4(size_t, const __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short4 |
| vldl24(size_t i, const __local short *p) |
| { |
| short4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl24"))) short4 vload4(size_t, const __local short *); |
| extern __attribute__((overloadable, weak, alias("vldl24"))) ushort4 vload4(size_t, const __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static int4 |
| vldp44(size_t i, const int *p) |
| { |
| int4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp44"))) int4 vload4(size_t, const int *); |
| extern __attribute__((overloadable, weak, alias("vldp44"))) uint4 vload4(size_t, const uint *); |
| |
| |
| |
| __attribute__((always_inline)) static int4 |
| vldc44(size_t i, const __constant int *p) |
| { |
| int4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc44"))) int4 vload4(size_t, const __constant int *); |
| extern __attribute__((overloadable, weak, alias("vldc44"))) uint4 vload4(size_t, const __constant uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int4 |
| vldg44(size_t i, const __global int *p) |
| { |
| int4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg44"))) int4 vload4(size_t, const __global int *); |
| extern __attribute__((overloadable, weak, alias("vldg44"))) uint4 vload4(size_t, const __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int4 |
| vldl44(size_t i, const __local int *p) |
| { |
| int4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl44"))) int4 vload4(size_t, const __local int *); |
| extern __attribute__((overloadable, weak, alias("vldl44"))) uint4 vload4(size_t, const __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static long4 |
| vldp84(size_t i, const long *p) |
| { |
| long4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp84"))) long4 vload4(size_t, const long *); |
| extern __attribute__((overloadable, weak, alias("vldp84"))) ulong4 vload4(size_t, const ulong *); |
| |
| |
| |
| __attribute__((always_inline)) static long4 |
| vldc84(size_t i, const __constant long *p) |
| { |
| long4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc84"))) long4 vload4(size_t, const __constant long *); |
| extern __attribute__((overloadable, weak, alias("vldc84"))) ulong4 vload4(size_t, const __constant ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long4 |
| vldg84(size_t i, const __global long *p) |
| { |
| long4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg84"))) long4 vload4(size_t, const __global long *); |
| extern __attribute__((overloadable, weak, alias("vldg84"))) ulong4 vload4(size_t, const __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long4 |
| vldl84(size_t i, const __local long *p) |
| { |
| long4 ret; |
| p += i * 4; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl84"))) long4 vload4(size_t, const __local long *); |
| extern __attribute__((overloadable, weak, alias("vldl84"))) ulong4 vload4(size_t, const __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static char8 |
| vldp18(size_t i, const char *p) |
| { |
| char8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp18"))) char8 vload8(size_t, const char *); |
| extern __attribute__((overloadable, weak, alias("vldp18"))) uchar8 vload8(size_t, const uchar *); |
| |
| |
| |
| __attribute__((always_inline)) static char8 |
| vldc18(size_t i, const __constant char *p) |
| { |
| char8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc18"))) char8 vload8(size_t, const __constant char *); |
| extern __attribute__((overloadable, weak, alias("vldc18"))) uchar8 vload8(size_t, const __constant uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char8 |
| vldg18(size_t i, const __global char *p) |
| { |
| char8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg18"))) char8 vload8(size_t, const __global char *); |
| extern __attribute__((overloadable, weak, alias("vldg18"))) uchar8 vload8(size_t, const __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char8 |
| vldl18(size_t i, const __local char *p) |
| { |
| char8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl18"))) char8 vload8(size_t, const __local char *); |
| extern __attribute__((overloadable, weak, alias("vldl18"))) uchar8 vload8(size_t, const __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static short8 |
| vldp28(size_t i, const short *p) |
| { |
| short8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp28"))) short8 vload8(size_t, const short *); |
| extern __attribute__((overloadable, weak, alias("vldp28"))) ushort8 vload8(size_t, const ushort *); |
| |
| |
| |
| __attribute__((always_inline)) static short8 |
| vldc28(size_t i, const __constant short *p) |
| { |
| short8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc28"))) short8 vload8(size_t, const __constant short *); |
| extern __attribute__((overloadable, weak, alias("vldc28"))) ushort8 vload8(size_t, const __constant ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short8 |
| vldg28(size_t i, const __global short *p) |
| { |
| short8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg28"))) short8 vload8(size_t, const __global short *); |
| extern __attribute__((overloadable, weak, alias("vldg28"))) ushort8 vload8(size_t, const __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short8 |
| vldl28(size_t i, const __local short *p) |
| { |
| short8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl28"))) short8 vload8(size_t, const __local short *); |
| extern __attribute__((overloadable, weak, alias("vldl28"))) ushort8 vload8(size_t, const __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static int8 |
| vldp48(size_t i, const int *p) |
| { |
| int8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp48"))) int8 vload8(size_t, const int *); |
| extern __attribute__((overloadable, weak, alias("vldp48"))) uint8 vload8(size_t, const uint *); |
| |
| |
| |
| __attribute__((always_inline)) static int8 |
| vldc48(size_t i, const __constant int *p) |
| { |
| int8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc48"))) int8 vload8(size_t, const __constant int *); |
| extern __attribute__((overloadable, weak, alias("vldc48"))) uint8 vload8(size_t, const __constant uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int8 |
| vldg48(size_t i, const __global int *p) |
| { |
| int8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg48"))) int8 vload8(size_t, const __global int *); |
| extern __attribute__((overloadable, weak, alias("vldg48"))) uint8 vload8(size_t, const __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int8 |
| vldl48(size_t i, const __local int *p) |
| { |
| int8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl48"))) int8 vload8(size_t, const __local int *); |
| extern __attribute__((overloadable, weak, alias("vldl48"))) uint8 vload8(size_t, const __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static long8 |
| vldp88(size_t i, const long *p) |
| { |
| long8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp88"))) long8 vload8(size_t, const long *); |
| extern __attribute__((overloadable, weak, alias("vldp88"))) ulong8 vload8(size_t, const ulong *); |
| |
| |
| |
| __attribute__((always_inline)) static long8 |
| vldc88(size_t i, const __constant long *p) |
| { |
| long8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc88"))) long8 vload8(size_t, const __constant long *); |
| extern __attribute__((overloadable, weak, alias("vldc88"))) ulong8 vload8(size_t, const __constant ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long8 |
| vldg88(size_t i, const __global long *p) |
| { |
| long8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg88"))) long8 vload8(size_t, const __global long *); |
| extern __attribute__((overloadable, weak, alias("vldg88"))) ulong8 vload8(size_t, const __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long8 |
| vldl88(size_t i, const __local long *p) |
| { |
| long8 ret; |
| p += i * 8; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl88"))) long8 vload8(size_t, const __local long *); |
| extern __attribute__((overloadable, weak, alias("vldl88"))) ulong8 vload8(size_t, const __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static char16 |
| vldp116(size_t i, const char *p) |
| { |
| char16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp116"))) char16 vload16(size_t, const char *); |
| extern __attribute__((overloadable, weak, alias("vldp116"))) uchar16 vload16(size_t, const uchar *); |
| |
| |
| |
| __attribute__((always_inline)) static char16 |
| vldc116(size_t i, const __constant char *p) |
| { |
| char16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc116"))) char16 vload16(size_t, const __constant char *); |
| extern __attribute__((overloadable, weak, alias("vldc116"))) uchar16 vload16(size_t, const __constant uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char16 |
| vldg116(size_t i, const __global char *p) |
| { |
| char16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg116"))) char16 vload16(size_t, const __global char *); |
| extern __attribute__((overloadable, weak, alias("vldg116"))) uchar16 vload16(size_t, const __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static char16 |
| vldl116(size_t i, const __local char *p) |
| { |
| char16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl116"))) char16 vload16(size_t, const __local char *); |
| extern __attribute__((overloadable, weak, alias("vldl116"))) uchar16 vload16(size_t, const __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static short16 |
| vldp216(size_t i, const short *p) |
| { |
| short16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp216"))) short16 vload16(size_t, const short *); |
| extern __attribute__((overloadable, weak, alias("vldp216"))) ushort16 vload16(size_t, const ushort *); |
| |
| |
| |
| __attribute__((always_inline)) static short16 |
| vldc216(size_t i, const __constant short *p) |
| { |
| short16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc216"))) short16 vload16(size_t, const __constant short *); |
| extern __attribute__((overloadable, weak, alias("vldc216"))) ushort16 vload16(size_t, const __constant ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short16 |
| vldg216(size_t i, const __global short *p) |
| { |
| short16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg216"))) short16 vload16(size_t, const __global short *); |
| extern __attribute__((overloadable, weak, alias("vldg216"))) ushort16 vload16(size_t, const __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static short16 |
| vldl216(size_t i, const __local short *p) |
| { |
| short16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl216"))) short16 vload16(size_t, const __local short *); |
| extern __attribute__((overloadable, weak, alias("vldl216"))) ushort16 vload16(size_t, const __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static int16 |
| vldp416(size_t i, const int *p) |
| { |
| int16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp416"))) int16 vload16(size_t, const int *); |
| extern __attribute__((overloadable, weak, alias("vldp416"))) uint16 vload16(size_t, const uint *); |
| |
| |
| |
| __attribute__((always_inline)) static int16 |
| vldc416(size_t i, const __constant int *p) |
| { |
| int16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc416"))) int16 vload16(size_t, const __constant int *); |
| extern __attribute__((overloadable, weak, alias("vldc416"))) uint16 vload16(size_t, const __constant uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int16 |
| vldg416(size_t i, const __global int *p) |
| { |
| int16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg416"))) int16 vload16(size_t, const __global int *); |
| extern __attribute__((overloadable, weak, alias("vldg416"))) uint16 vload16(size_t, const __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static int16 |
| vldl416(size_t i, const __local int *p) |
| { |
| int16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl416"))) int16 vload16(size_t, const __local int *); |
| extern __attribute__((overloadable, weak, alias("vldl416"))) uint16 vload16(size_t, const __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static long16 |
| vldp816(size_t i, const long *p) |
| { |
| long16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldp816"))) long16 vload16(size_t, const long *); |
| extern __attribute__((overloadable, weak, alias("vldp816"))) ulong16 vload16(size_t, const ulong *); |
| |
| |
| |
| __attribute__((always_inline)) static long16 |
| vldc816(size_t i, const __constant long *p) |
| { |
| long16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldc816"))) long16 vload16(size_t, const __constant long *); |
| extern __attribute__((overloadable, weak, alias("vldc816"))) ulong16 vload16(size_t, const __constant ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long16 |
| vldg816(size_t i, const __global long *p) |
| { |
| long16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldg816"))) long16 vload16(size_t, const __global long *); |
| extern __attribute__((overloadable, weak, alias("vldg816"))) ulong16 vload16(size_t, const __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static long16 |
| vldl816(size_t i, const __local long *p) |
| { |
| long16 ret; |
| p += i * 16; |
| ret.s0 = p[0]; |
| ret.s1 = p[1]; |
| ret.s2 = p[2]; |
| ret.s3 = p[3]; |
| ret.s4 = p[4]; |
| ret.s5 = p[5]; |
| ret.s6 = p[6]; |
| ret.s7 = p[7]; |
| ret.s8 = p[8]; |
| ret.s9 = p[9]; |
| ret.sa = p[10]; |
| ret.sb = p[11]; |
| ret.sc = p[12]; |
| ret.sd = p[13]; |
| ret.se = p[14]; |
| ret.sf = p[15]; |
| |
| return ret; |
| } |
| extern __attribute__((overloadable, weak, alias("vldl816"))) long16 vload16(size_t, const __local long *); |
| extern __attribute__((overloadable, weak, alias("vldl816"))) ulong16 vload16(size_t, const __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp12(char2 v, size_t i, char *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp12"))) void vstore2( char2, size_t, char *); |
| extern __attribute__((overloadable, weak, alias("vstp12"))) void vstore2(uchar2, size_t, uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg12(char2 v, size_t i, __global char *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg12"))) void vstore2( char2, size_t, __global char *); |
| extern __attribute__((overloadable, weak, alias("vstg12"))) void vstore2(uchar2, size_t, __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl12(char2 v, size_t i, __local char *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl12"))) void vstore2( char2, size_t, __local char *); |
| extern __attribute__((overloadable, weak, alias("vstl12"))) void vstore2(uchar2, size_t, __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp22(short2 v, size_t i, short *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp22"))) void vstore2( short2, size_t, short *); |
| extern __attribute__((overloadable, weak, alias("vstp22"))) void vstore2(ushort2, size_t, ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg22(short2 v, size_t i, __global short *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg22"))) void vstore2( short2, size_t, __global short *); |
| extern __attribute__((overloadable, weak, alias("vstg22"))) void vstore2(ushort2, size_t, __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl22(short2 v, size_t i, __local short *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl22"))) void vstore2( short2, size_t, __local short *); |
| extern __attribute__((overloadable, weak, alias("vstl22"))) void vstore2(ushort2, size_t, __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp42(int2 v, size_t i, int *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp42"))) void vstore2( int2, size_t, int *); |
| extern __attribute__((overloadable, weak, alias("vstp42"))) void vstore2(uint2, size_t, uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg42(int2 v, size_t i, __global int *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg42"))) void vstore2( int2, size_t, __global int *); |
| extern __attribute__((overloadable, weak, alias("vstg42"))) void vstore2(uint2, size_t, __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl42(int2 v, size_t i, __local int *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl42"))) void vstore2( int2, size_t, __local int *); |
| extern __attribute__((overloadable, weak, alias("vstl42"))) void vstore2(uint2, size_t, __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp82(long2 v, size_t i, long *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp82"))) void vstore2( long2, size_t, long *); |
| extern __attribute__((overloadable, weak, alias("vstp82"))) void vstore2(ulong2, size_t, ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg82(long2 v, size_t i, __global long *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg82"))) void vstore2( long2, size_t, __global long *); |
| extern __attribute__((overloadable, weak, alias("vstg82"))) void vstore2(ulong2, size_t, __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl82(long2 v, size_t i, __local long *p) |
| { |
| p += i * 2; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl82"))) void vstore2( long2, size_t, __local long *); |
| extern __attribute__((overloadable, weak, alias("vstl82"))) void vstore2(ulong2, size_t, __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp13(char3 v, size_t i, char *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp13"))) void vstore3( char3, size_t, char *); |
| extern __attribute__((overloadable, weak, alias("vstp13"))) void vstore3(uchar3, size_t, uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg13(char3 v, size_t i, __global char *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg13"))) void vstore3( char3, size_t, __global char *); |
| extern __attribute__((overloadable, weak, alias("vstg13"))) void vstore3(uchar3, size_t, __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl13(char3 v, size_t i, __local char *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl13"))) void vstore3( char3, size_t, __local char *); |
| extern __attribute__((overloadable, weak, alias("vstl13"))) void vstore3(uchar3, size_t, __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp23(short3 v, size_t i, short *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp23"))) void vstore3( short3, size_t, short *); |
| extern __attribute__((overloadable, weak, alias("vstp23"))) void vstore3(ushort3, size_t, ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg23(short3 v, size_t i, __global short *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg23"))) void vstore3( short3, size_t, __global short *); |
| extern __attribute__((overloadable, weak, alias("vstg23"))) void vstore3(ushort3, size_t, __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl23(short3 v, size_t i, __local short *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl23"))) void vstore3( short3, size_t, __local short *); |
| extern __attribute__((overloadable, weak, alias("vstl23"))) void vstore3(ushort3, size_t, __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp43(int3 v, size_t i, int *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp43"))) void vstore3( int3, size_t, int *); |
| extern __attribute__((overloadable, weak, alias("vstp43"))) void vstore3(uint3, size_t, uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg43(int3 v, size_t i, __global int *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg43"))) void vstore3( int3, size_t, __global int *); |
| extern __attribute__((overloadable, weak, alias("vstg43"))) void vstore3(uint3, size_t, __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl43(int3 v, size_t i, __local int *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl43"))) void vstore3( int3, size_t, __local int *); |
| extern __attribute__((overloadable, weak, alias("vstl43"))) void vstore3(uint3, size_t, __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp83(long3 v, size_t i, long *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp83"))) void vstore3( long3, size_t, long *); |
| extern __attribute__((overloadable, weak, alias("vstp83"))) void vstore3(ulong3, size_t, ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg83(long3 v, size_t i, __global long *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg83"))) void vstore3( long3, size_t, __global long *); |
| extern __attribute__((overloadable, weak, alias("vstg83"))) void vstore3(ulong3, size_t, __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl83(long3 v, size_t i, __local long *p) |
| { |
| p += i * 3; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl83"))) void vstore3( long3, size_t, __local long *); |
| extern __attribute__((overloadable, weak, alias("vstl83"))) void vstore3(ulong3, size_t, __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp14(char4 v, size_t i, char *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp14"))) void vstore4( char4, size_t, char *); |
| extern __attribute__((overloadable, weak, alias("vstp14"))) void vstore4(uchar4, size_t, uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg14(char4 v, size_t i, __global char *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg14"))) void vstore4( char4, size_t, __global char *); |
| extern __attribute__((overloadable, weak, alias("vstg14"))) void vstore4(uchar4, size_t, __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl14(char4 v, size_t i, __local char *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl14"))) void vstore4( char4, size_t, __local char *); |
| extern __attribute__((overloadable, weak, alias("vstl14"))) void vstore4(uchar4, size_t, __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp24(short4 v, size_t i, short *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp24"))) void vstore4( short4, size_t, short *); |
| extern __attribute__((overloadable, weak, alias("vstp24"))) void vstore4(ushort4, size_t, ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg24(short4 v, size_t i, __global short *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg24"))) void vstore4( short4, size_t, __global short *); |
| extern __attribute__((overloadable, weak, alias("vstg24"))) void vstore4(ushort4, size_t, __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl24(short4 v, size_t i, __local short *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl24"))) void vstore4( short4, size_t, __local short *); |
| extern __attribute__((overloadable, weak, alias("vstl24"))) void vstore4(ushort4, size_t, __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp44(int4 v, size_t i, int *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp44"))) void vstore4( int4, size_t, int *); |
| extern __attribute__((overloadable, weak, alias("vstp44"))) void vstore4(uint4, size_t, uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg44(int4 v, size_t i, __global int *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg44"))) void vstore4( int4, size_t, __global int *); |
| extern __attribute__((overloadable, weak, alias("vstg44"))) void vstore4(uint4, size_t, __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl44(int4 v, size_t i, __local int *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl44"))) void vstore4( int4, size_t, __local int *); |
| extern __attribute__((overloadable, weak, alias("vstl44"))) void vstore4(uint4, size_t, __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp84(long4 v, size_t i, long *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp84"))) void vstore4( long4, size_t, long *); |
| extern __attribute__((overloadable, weak, alias("vstp84"))) void vstore4(ulong4, size_t, ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg84(long4 v, size_t i, __global long *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg84"))) void vstore4( long4, size_t, __global long *); |
| extern __attribute__((overloadable, weak, alias("vstg84"))) void vstore4(ulong4, size_t, __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl84(long4 v, size_t i, __local long *p) |
| { |
| p += i * 4; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl84"))) void vstore4( long4, size_t, __local long *); |
| extern __attribute__((overloadable, weak, alias("vstl84"))) void vstore4(ulong4, size_t, __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp18(char8 v, size_t i, char *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp18"))) void vstore8( char8, size_t, char *); |
| extern __attribute__((overloadable, weak, alias("vstp18"))) void vstore8(uchar8, size_t, uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg18(char8 v, size_t i, __global char *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg18"))) void vstore8( char8, size_t, __global char *); |
| extern __attribute__((overloadable, weak, alias("vstg18"))) void vstore8(uchar8, size_t, __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl18(char8 v, size_t i, __local char *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl18"))) void vstore8( char8, size_t, __local char *); |
| extern __attribute__((overloadable, weak, alias("vstl18"))) void vstore8(uchar8, size_t, __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp28(short8 v, size_t i, short *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp28"))) void vstore8( short8, size_t, short *); |
| extern __attribute__((overloadable, weak, alias("vstp28"))) void vstore8(ushort8, size_t, ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg28(short8 v, size_t i, __global short *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg28"))) void vstore8( short8, size_t, __global short *); |
| extern __attribute__((overloadable, weak, alias("vstg28"))) void vstore8(ushort8, size_t, __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl28(short8 v, size_t i, __local short *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl28"))) void vstore8( short8, size_t, __local short *); |
| extern __attribute__((overloadable, weak, alias("vstl28"))) void vstore8(ushort8, size_t, __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp48(int8 v, size_t i, int *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp48"))) void vstore8( int8, size_t, int *); |
| extern __attribute__((overloadable, weak, alias("vstp48"))) void vstore8(uint8, size_t, uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg48(int8 v, size_t i, __global int *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg48"))) void vstore8( int8, size_t, __global int *); |
| extern __attribute__((overloadable, weak, alias("vstg48"))) void vstore8(uint8, size_t, __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl48(int8 v, size_t i, __local int *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl48"))) void vstore8( int8, size_t, __local int *); |
| extern __attribute__((overloadable, weak, alias("vstl48"))) void vstore8(uint8, size_t, __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp88(long8 v, size_t i, long *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp88"))) void vstore8( long8, size_t, long *); |
| extern __attribute__((overloadable, weak, alias("vstp88"))) void vstore8(ulong8, size_t, ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg88(long8 v, size_t i, __global long *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg88"))) void vstore8( long8, size_t, __global long *); |
| extern __attribute__((overloadable, weak, alias("vstg88"))) void vstore8(ulong8, size_t, __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl88(long8 v, size_t i, __local long *p) |
| { |
| p += i * 8; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl88"))) void vstore8( long8, size_t, __local long *); |
| extern __attribute__((overloadable, weak, alias("vstl88"))) void vstore8(ulong8, size_t, __local ulong *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp116(char16 v, size_t i, char *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp116"))) void vstore16( char16, size_t, char *); |
| extern __attribute__((overloadable, weak, alias("vstp116"))) void vstore16(uchar16, size_t, uchar *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg116(char16 v, size_t i, __global char *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg116"))) void vstore16( char16, size_t, __global char *); |
| extern __attribute__((overloadable, weak, alias("vstg116"))) void vstore16(uchar16, size_t, __global uchar *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl116(char16 v, size_t i, __local char *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl116"))) void vstore16( char16, size_t, __local char *); |
| extern __attribute__((overloadable, weak, alias("vstl116"))) void vstore16(uchar16, size_t, __local uchar *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp216(short16 v, size_t i, short *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp216"))) void vstore16( short16, size_t, short *); |
| extern __attribute__((overloadable, weak, alias("vstp216"))) void vstore16(ushort16, size_t, ushort *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg216(short16 v, size_t i, __global short *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg216"))) void vstore16( short16, size_t, __global short *); |
| extern __attribute__((overloadable, weak, alias("vstg216"))) void vstore16(ushort16, size_t, __global ushort *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl216(short16 v, size_t i, __local short *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl216"))) void vstore16( short16, size_t, __local short *); |
| extern __attribute__((overloadable, weak, alias("vstl216"))) void vstore16(ushort16, size_t, __local ushort *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp416(int16 v, size_t i, int *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp416"))) void vstore16( int16, size_t, int *); |
| extern __attribute__((overloadable, weak, alias("vstp416"))) void vstore16(uint16, size_t, uint *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg416(int16 v, size_t i, __global int *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg416"))) void vstore16( int16, size_t, __global int *); |
| extern __attribute__((overloadable, weak, alias("vstg416"))) void vstore16(uint16, size_t, __global uint *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl416(int16 v, size_t i, __local int *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl416"))) void vstore16( int16, size_t, __local int *); |
| extern __attribute__((overloadable, weak, alias("vstl416"))) void vstore16(uint16, size_t, __local uint *); |
| #endif |
| |
| |
| __attribute__((always_inline)) static void |
| vstp816(long16 v, size_t i, long *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstp816"))) void vstore16( long16, size_t, long *); |
| extern __attribute__((overloadable, weak, alias("vstp816"))) void vstore16(ulong16, size_t, ulong *); |
| |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstg816(long16 v, size_t i, __global long *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstg816"))) void vstore16( long16, size_t, __global long *); |
| extern __attribute__((overloadable, weak, alias("vstg816"))) void vstore16(ulong16, size_t, __global ulong *); |
| #endif |
| |
| #if __OPENCL_C_VERSION__ < 200 |
| __attribute__((always_inline)) static void |
| vstl816(long16 v, size_t i, __local long *p) |
| { |
| p += i * 16; |
| p[0] = v.s0; |
| p[1] = v.s1; |
| p[2] = v.s2; |
| p[3] = v.s3; |
| p[4] = v.s4; |
| p[5] = v.s5; |
| p[6] = v.s6; |
| p[7] = v.s7; |
| p[8] = v.s8; |
| p[9] = v.s9; |
| p[10] = v.sa; |
| p[11] = v.sb; |
| p[12] = v.sc; |
| p[13] = v.sd; |
| p[14] = v.se; |
| p[15] = v.sf; |
| |
| } |
| extern __attribute__((overloadable, weak, alias("vstl816"))) void vstore16( long16, size_t, __local long *); |
| extern __attribute__((overloadable, weak, alias("vstl816"))) void vstore16(ulong16, size_t, __local ulong *); |
| #endif |
| |