Subversion Repositories Kolibri OS

 

 

 

    /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */

    #include <AvailabilityMacros.h>

 

extern "C" {

 

    #define CL_API_ENTRY

    #define CL_API_CALL     __stdcall

    #define CL_CALLBACK     __stdcall

    #define CL_API_ENTRY

    #define CL_API_CALL

    #define CL_CALLBACK

 

    #define CL_EXTENSION_WEAK_LINK                  __attribute__((weak_import))      

    #define CL_API_SUFFIX__VERSION_1_0              AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER

    #define CL_EXT_SUFFIX__VERSION_1_0              CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER

    #define CL_API_SUFFIX__VERSION_1_1              CL_EXTENSION_WEAK_LINK

    #define CL_EXT_SUFFIX__VERSION_1_1              CL_EXTENSION_WEAK_LINK

    #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED   CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER

    #define CL_EXTENSION_WEAK_LINK                        

    #define CL_API_SUFFIX__VERSION_1_0

    #define CL_EXT_SUFFIX__VERSION_1_0

    #define CL_API_SUFFIX__VERSION_1_1

    #define CL_EXT_SUFFIX__VERSION_1_1

    #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED

 

 

typedef signed   __int8         cl_char;

typedef unsigned __int8         cl_uchar;

typedef signed   __int16        cl_short;

typedef unsigned __int16        cl_ushort;

typedef signed   __int32        cl_int;

typedef unsigned __int32        cl_uint;

typedef signed   __int64        cl_long;

typedef unsigned __int64        cl_ulong;

 

typedef unsigned __int16        cl_half;

typedef float                   cl_float;

typedef double                  cl_double;

 

 

 

 

 

 

 

 

 

typedef int8_t          cl_char;

typedef uint8_t         cl_uchar;

typedef int16_t         cl_short    __attribute__((aligned(2)));

typedef uint16_t        cl_ushort   __attribute__((aligned(2)));

typedef int32_t         cl_int      __attribute__((aligned(4)));

typedef uint32_t        cl_uint     __attribute__((aligned(4)));

typedef int64_t         cl_long     __attribute__((aligned(8)));

typedef uint64_t        cl_ulong    __attribute__((aligned(8)));

 

typedef uint16_t        cl_half     __attribute__((aligned(2)));

typedef float           cl_float    __attribute__((aligned(4)));

typedef double          cl_double   __attribute__((aligned(8)));

 

 

 

 

 

 

   #define CL_HUGE_VALF     __builtin_huge_valf()

   #define CL_HUGE_VAL      __builtin_huge_val()

   #define CL_NAN           __builtin_nanf( "" )

   #define CL_HUGE_VALF     ((cl_float) 1e50)

   #define CL_HUGE_VAL      ((cl_double) 1e500)

   float nanf( const char * );

   #define CL_NAN           nanf( "" )  

 

 

 

typedef unsigned int cl_GLuint;

typedef int          cl_GLint;

typedef unsigned int cl_GLenum;

 

 

   #include <altivec.h>   /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */

   typedef vector unsigned char     __cl_uchar16;

   typedef vector signed char       __cl_char16;

   typedef vector unsigned short    __cl_ushort8;

   typedef vector signed short      __cl_short8;

   typedef vector unsigned int      __cl_uint4;

   typedef vector signed int        __cl_int4;

   typedef vector float             __cl_float4;

   #define  __CL_UCHAR16__  1

   #define  __CL_CHAR16__   1

   #define  __CL_USHORT8__  1

   #define  __CL_SHORT8__   1

   #define  __CL_UINT4__    1

   #define  __CL_INT4__     1

   #define  __CL_FLOAT4__   1

 

    #if defined( __MINGW64__ )

        #include <intrin.h>

    #else

        #include <xmmintrin.h>

    #endif

    #if defined( __GNUC__ )

        typedef float __cl_float4   __attribute__((vector_size(16)));

    #else

        typedef __m128 __cl_float4;

    #endif

    #define __CL_FLOAT4__   1

 

    #if defined( __MINGW64__ )

        #include <intrin.h>

    #else

        #include <emmintrin.h>

    #endif

    #if defined( __GNUC__ )

        typedef cl_uchar    __cl_uchar16    __attribute__((vector_size(16)));

        typedef cl_char     __cl_char16     __attribute__((vector_size(16)));

        typedef cl_ushort   __cl_ushort8    __attribute__((vector_size(16)));

        typedef cl_short    __cl_short8     __attribute__((vector_size(16)));

        typedef cl_uint     __cl_uint4      __attribute__((vector_size(16)));

        typedef cl_int      __cl_int4       __attribute__((vector_size(16)));

        typedef cl_ulong    __cl_ulong2     __attribute__((vector_size(16)));

        typedef cl_long     __cl_long2      __attribute__((vector_size(16)));

        typedef cl_double   __cl_double2    __attribute__((vector_size(16)));

    #else

        typedef __m128i __cl_uchar16;

        typedef __m128i __cl_char16;

        typedef __m128i __cl_ushort8;

        typedef __m128i __cl_short8;

        typedef __m128i __cl_uint4;

        typedef __m128i __cl_int4;

        typedef __m128i __cl_ulong2;

        typedef __m128i __cl_long2;

        typedef __m128d __cl_double2;

    #endif

    #define __CL_UCHAR16__  1

    #define __CL_CHAR16__   1

    #define __CL_USHORT8__  1

    #define __CL_SHORT8__   1

    #define __CL_INT4__     1

    #define __CL_UINT4__    1

    #define __CL_ULONG2__   1

    #define __CL_LONG2__    1

    #define __CL_DOUBLE2__  1

 

    #include <mmintrin.h>

    #if defined( __GNUC__ )

        typedef cl_uchar    __cl_uchar8     __attribute__((vector_size(8)));

        typedef cl_char     __cl_char8      __attribute__((vector_size(8)));

        typedef cl_ushort   __cl_ushort4    __attribute__((vector_size(8)));

        typedef cl_short    __cl_short4     __attribute__((vector_size(8)));

        typedef cl_uint     __cl_uint2      __attribute__((vector_size(8)));

        typedef cl_int      __cl_int2       __attribute__((vector_size(8)));

        typedef cl_ulong    __cl_ulong1     __attribute__((vector_size(8)));

        typedef cl_long     __cl_long1      __attribute__((vector_size(8)));

        typedef cl_float    __cl_float2     __attribute__((vector_size(8)));

    #else

        typedef __m64       __cl_uchar8;

        typedef __m64       __cl_char8;

        typedef __m64       __cl_ushort4;

        typedef __m64       __cl_short4;

        typedef __m64       __cl_uint2;

        typedef __m64       __cl_int2;

        typedef __m64       __cl_ulong1;

        typedef __m64       __cl_long1;

        typedef __m64       __cl_float2;

    #endif

    #define __CL_UCHAR8__   1

    #define __CL_CHAR8__    1

    #define __CL_USHORT4__  1

    #define __CL_SHORT4__   1

    #define __CL_INT2__     1

    #define __CL_UINT2__    1

    #define __CL_ULONG1__   1

    #define __CL_LONG1__    1

    #define __CL_FLOAT2__   1

 

    #if defined( __MINGW64__ )

        #include <intrin.h>

    #else

        #include <immintrin.h>

    #endif

    #if defined( __GNUC__ )

        typedef cl_float    __cl_float8     __attribute__((vector_size(32)));

        typedef cl_double   __cl_double4    __attribute__((vector_size(32)));

    #else

        typedef __m256      __cl_float8;

        typedef __m256d     __cl_double4;

    #endif

    #define __CL_FLOAT8__   1

    #define __CL_DOUBLE4__  1

 

    #define CL_ALIGNED(_x)          __attribute__ ((aligned(_x)))

    /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements     */

    /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx                                                 */

    /* #include <crtdefs.h>                                                                                             */

    /* #define CL_ALIGNED(_x)          _CRT_ALIGN(_x)                                                                   */

    #define CL_ALIGNED(_x)

   #warning  Need to implement some method to align data here

   #define  CL_ALIGNED(_x)

 

    /* .xyzw and .s0123...{f|F} are supported */

    #define CL_HAS_NAMED_VECTOR_FIELDS 1

    /* .hi and .lo are supported */

    #define CL_HAS_HI_LO_VECTOR_FIELDS 1

 

 

typedef union

    cl_char  CL_ALIGNED(2) s[2];

   __extension__ struct{ cl_char  x, y; };

   __extension__ struct{ cl_char  s0, s1; };

   __extension__ struct{ cl_char  lo, hi; };

    __cl_char2     v2;

}cl_char2;

 

typedef union

    cl_char  CL_ALIGNED(4) s[4];

   __extension__ struct{ cl_char  x, y, z, w; };

   __extension__ struct{ cl_char  s0, s1, s2, s3; };

   __extension__ struct{ cl_char2 lo, hi; };

    __cl_char2     v2[2];

    __cl_char4     v4;

}cl_char4;

 

typedef  cl_char4  cl_char3;

 

typedef union

    cl_char   CL_ALIGNED(8) s[8];

   __extension__ struct{ cl_char  x, y, z, w; };

   __extension__ struct{ cl_char  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_char4 lo, hi; };

    __cl_char2     v2[4];

    __cl_char4     v4[2];

    __cl_char8     v8;

}cl_char8;

 

typedef union

    cl_char  CL_ALIGNED(16) s[16];

   __extension__ struct{ cl_char  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_char  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_char8 lo, hi; };

    __cl_char2     v2[8];

    __cl_char4     v4[4];

    __cl_char8     v8[2];

    __cl_char16    v16;

}cl_char16;

 

 

typedef union

    cl_uchar  CL_ALIGNED(2) s[2];

   __extension__ struct{ cl_uchar  x, y; };

   __extension__ struct{ cl_uchar  s0, s1; };

   __extension__ struct{ cl_uchar  lo, hi; };

    __cl_uchar2     v2;

}cl_uchar2;

 

typedef union

    cl_uchar  CL_ALIGNED(4) s[4];

   __extension__ struct{ cl_uchar  x, y, z, w; };

   __extension__ struct{ cl_uchar  s0, s1, s2, s3; };

   __extension__ struct{ cl_uchar2 lo, hi; };

    __cl_uchar2     v2[2];

    __cl_uchar4     v4;

}cl_uchar4;

 

typedef  cl_uchar4  cl_uchar3;

 

typedef union

    cl_uchar   CL_ALIGNED(8) s[8];

   __extension__ struct{ cl_uchar  x, y, z, w; };

   __extension__ struct{ cl_uchar  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_uchar4 lo, hi; };

    __cl_uchar2     v2[4];

    __cl_uchar4     v4[2];

    __cl_uchar8     v8;

}cl_uchar8;

 

typedef union

    cl_uchar  CL_ALIGNED(16) s[16];

   __extension__ struct{ cl_uchar  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_uchar  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_uchar8 lo, hi; };

    __cl_uchar2     v2[8];

    __cl_uchar4     v4[4];

    __cl_uchar8     v8[2];

    __cl_uchar16    v16;

}cl_uchar16;

 

 

typedef union

    cl_short  CL_ALIGNED(4) s[2];

   __extension__ struct{ cl_short  x, y; };

   __extension__ struct{ cl_short  s0, s1; };

   __extension__ struct{ cl_short  lo, hi; };

    __cl_short2     v2;

}cl_short2;

 

typedef union

    cl_short  CL_ALIGNED(8) s[4];

   __extension__ struct{ cl_short  x, y, z, w; };

   __extension__ struct{ cl_short  s0, s1, s2, s3; };

   __extension__ struct{ cl_short2 lo, hi; };

    __cl_short2     v2[2];

    __cl_short4     v4;

}cl_short4;

 

typedef  cl_short4  cl_short3;

 

typedef union

    cl_short   CL_ALIGNED(16) s[8];

   __extension__ struct{ cl_short  x, y, z, w; };

   __extension__ struct{ cl_short  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_short4 lo, hi; };

    __cl_short2     v2[4];

    __cl_short4     v4[2];

    __cl_short8     v8;

}cl_short8;

 

typedef union

    cl_short  CL_ALIGNED(32) s[16];

   __extension__ struct{ cl_short  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_short  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_short8 lo, hi; };

    __cl_short2     v2[8];

    __cl_short4     v4[4];

    __cl_short8     v8[2];

    __cl_short16    v16;

}cl_short16;

 

 

typedef union

    cl_ushort  CL_ALIGNED(4) s[2];

   __extension__ struct{ cl_ushort  x, y; };

   __extension__ struct{ cl_ushort  s0, s1; };

   __extension__ struct{ cl_ushort  lo, hi; };

    __cl_ushort2     v2;

}cl_ushort2;

 

typedef union

    cl_ushort  CL_ALIGNED(8) s[4];

   __extension__ struct{ cl_ushort  x, y, z, w; };

   __extension__ struct{ cl_ushort  s0, s1, s2, s3; };

   __extension__ struct{ cl_ushort2 lo, hi; };

    __cl_ushort2     v2[2];

    __cl_ushort4     v4;

}cl_ushort4;

 

typedef  cl_ushort4  cl_ushort3;

 

typedef union

    cl_ushort   CL_ALIGNED(16) s[8];

   __extension__ struct{ cl_ushort  x, y, z, w; };

   __extension__ struct{ cl_ushort  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_ushort4 lo, hi; };

    __cl_ushort2     v2[4];

    __cl_ushort4     v4[2];

    __cl_ushort8     v8;

}cl_ushort8;

 

typedef union

    cl_ushort  CL_ALIGNED(32) s[16];

   __extension__ struct{ cl_ushort  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_ushort  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_ushort8 lo, hi; };

    __cl_ushort2     v2[8];

    __cl_ushort4     v4[4];

    __cl_ushort8     v8[2];

    __cl_ushort16    v16;

}cl_ushort16;

 

typedef union

    cl_int  CL_ALIGNED(8) s[2];

   __extension__ struct{ cl_int  x, y; };

   __extension__ struct{ cl_int  s0, s1; };

   __extension__ struct{ cl_int  lo, hi; };

    __cl_int2     v2;

}cl_int2;

 

typedef union

    cl_int  CL_ALIGNED(16) s[4];

   __extension__ struct{ cl_int  x, y, z, w; };

   __extension__ struct{ cl_int  s0, s1, s2, s3; };

   __extension__ struct{ cl_int2 lo, hi; };

    __cl_int2     v2[2];

    __cl_int4     v4;

}cl_int4;

 

typedef  cl_int4  cl_int3;

 

typedef union

    cl_int   CL_ALIGNED(32) s[8];

   __extension__ struct{ cl_int  x, y, z, w; };

   __extension__ struct{ cl_int  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_int4 lo, hi; };

    __cl_int2     v2[4];

    __cl_int4     v4[2];

    __cl_int8     v8;

}cl_int8;

 

typedef union

    cl_int  CL_ALIGNED(64) s[16];

   __extension__ struct{ cl_int  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_int  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_int8 lo, hi; };

    __cl_int2     v2[8];

    __cl_int4     v4[4];

    __cl_int8     v8[2];

    __cl_int16    v16;

}cl_int16;

 

 

typedef union

    cl_uint  CL_ALIGNED(8) s[2];

   __extension__ struct{ cl_uint  x, y; };

   __extension__ struct{ cl_uint  s0, s1; };

   __extension__ struct{ cl_uint  lo, hi; };

    __cl_uint2     v2;

}cl_uint2;

 

typedef union

    cl_uint  CL_ALIGNED(16) s[4];

   __extension__ struct{ cl_uint  x, y, z, w; };

   __extension__ struct{ cl_uint  s0, s1, s2, s3; };

   __extension__ struct{ cl_uint2 lo, hi; };

    __cl_uint2     v2[2];

    __cl_uint4     v4;

}cl_uint4;

 

typedef  cl_uint4  cl_uint3;

 

typedef union

    cl_uint   CL_ALIGNED(32) s[8];

   __extension__ struct{ cl_uint  x, y, z, w; };

   __extension__ struct{ cl_uint  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_uint4 lo, hi; };

    __cl_uint2     v2[4];

    __cl_uint4     v4[2];

    __cl_uint8     v8;

}cl_uint8;

 

typedef union

    cl_uint  CL_ALIGNED(64) s[16];

   __extension__ struct{ cl_uint  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_uint  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_uint8 lo, hi; };

    __cl_uint2     v2[8];

    __cl_uint4     v4[4];

    __cl_uint8     v8[2];

    __cl_uint16    v16;

}cl_uint16;

 

typedef union

    cl_long  CL_ALIGNED(16) s[2];

   __extension__ struct{ cl_long  x, y; };

   __extension__ struct{ cl_long  s0, s1; };

   __extension__ struct{ cl_long  lo, hi; };

    __cl_long2     v2;

}cl_long2;

 

typedef union

    cl_long  CL_ALIGNED(32) s[4];

   __extension__ struct{ cl_long  x, y, z, w; };

   __extension__ struct{ cl_long  s0, s1, s2, s3; };

   __extension__ struct{ cl_long2 lo, hi; };

    __cl_long2     v2[2];

    __cl_long4     v4;

}cl_long4;

 

typedef  cl_long4  cl_long3;

 

typedef union

    cl_long   CL_ALIGNED(64) s[8];

   __extension__ struct{ cl_long  x, y, z, w; };

   __extension__ struct{ cl_long  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_long4 lo, hi; };

    __cl_long2     v2[4];

    __cl_long4     v4[2];

    __cl_long8     v8;

}cl_long8;

 

typedef union

    cl_long  CL_ALIGNED(128) s[16];

   __extension__ struct{ cl_long  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_long  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_long8 lo, hi; };

    __cl_long2     v2[8];

    __cl_long4     v4[4];

    __cl_long8     v8[2];

    __cl_long16    v16;

}cl_long16;

 

 

typedef union

    cl_ulong  CL_ALIGNED(16) s[2];

   __extension__ struct{ cl_ulong  x, y; };

   __extension__ struct{ cl_ulong  s0, s1; };

   __extension__ struct{ cl_ulong  lo, hi; };

    __cl_ulong2     v2;

}cl_ulong2;

 

typedef union

    cl_ulong  CL_ALIGNED(32) s[4];

   __extension__ struct{ cl_ulong  x, y, z, w; };

   __extension__ struct{ cl_ulong  s0, s1, s2, s3; };

   __extension__ struct{ cl_ulong2 lo, hi; };

    __cl_ulong2     v2[2];

    __cl_ulong4     v4;

}cl_ulong4;

 

typedef  cl_ulong4  cl_ulong3;

 

typedef union

    cl_ulong   CL_ALIGNED(64) s[8];

   __extension__ struct{ cl_ulong  x, y, z, w; };

   __extension__ struct{ cl_ulong  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_ulong4 lo, hi; };

    __cl_ulong2     v2[4];

    __cl_ulong4     v4[2];

    __cl_ulong8     v8;

}cl_ulong8;

 

typedef union

    cl_ulong  CL_ALIGNED(128) s[16];

   __extension__ struct{ cl_ulong  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_ulong  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_ulong8 lo, hi; };

    __cl_ulong2     v2[8];

    __cl_ulong4     v4[4];

    __cl_ulong8     v8[2];

    __cl_ulong16    v16;

}cl_ulong16;

 

 

 

typedef union

    cl_float  CL_ALIGNED(8) s[2];

   __extension__ struct{ cl_float  x, y; };

   __extension__ struct{ cl_float  s0, s1; };

   __extension__ struct{ cl_float  lo, hi; };

    __cl_float2     v2;

}cl_float2;

 

typedef union

    cl_float  CL_ALIGNED(16) s[4];

   __extension__ struct{ cl_float   x, y, z, w; };

   __extension__ struct{ cl_float   s0, s1, s2, s3; };

   __extension__ struct{ cl_float2  lo, hi; };

    __cl_float2     v2[2];

    __cl_float4     v4;

}cl_float4;

 

typedef  cl_float4  cl_float3;

 

typedef union

    cl_float   CL_ALIGNED(32) s[8];

   __extension__ struct{ cl_float   x, y, z, w; };

   __extension__ struct{ cl_float   s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_float4  lo, hi; };

    __cl_float2     v2[4];

    __cl_float4     v4[2];

    __cl_float8     v8;

}cl_float8;

 

typedef union

    cl_float  CL_ALIGNED(64) s[16];

   __extension__ struct{ cl_float  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_float  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_float8 lo, hi; };

    __cl_float2     v2[8];

    __cl_float4     v4[4];

    __cl_float8     v8[2];

    __cl_float16    v16;

}cl_float16;

 

 

typedef union

    cl_double  CL_ALIGNED(16) s[2];

   __extension__ struct{ cl_double  x, y; };

   __extension__ struct{ cl_double s0, s1; };

   __extension__ struct{ cl_double lo, hi; };

    __cl_double2     v2;

}cl_double2;

 

typedef union

    cl_double  CL_ALIGNED(32) s[4];

   __extension__ struct{ cl_double  x, y, z, w; };

   __extension__ struct{ cl_double  s0, s1, s2, s3; };

   __extension__ struct{ cl_double2 lo, hi; };

    __cl_double2     v2[2];

    __cl_double4     v4;

}cl_double4;

 

typedef  cl_double4  cl_double3;

 

typedef union

    cl_double   CL_ALIGNED(64) s[8];

   __extension__ struct{ cl_double  x, y, z, w; };

   __extension__ struct{ cl_double  s0, s1, s2, s3, s4, s5, s6, s7; };

   __extension__ struct{ cl_double4 lo, hi; };

    __cl_double2     v2[4];

    __cl_double4     v4[2];

    __cl_double8     v8;

}cl_double8;

 

typedef union

    cl_double  CL_ALIGNED(128) s[16];

   __extension__ struct{ cl_double  x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };

   __extension__ struct{ cl_double  s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };

   __extension__ struct{ cl_double8 lo, hi; };

    __cl_double2     v2[8];

    __cl_double4     v4[4];

    __cl_double8     v8[2];

    __cl_double16    v16;

}cl_double16;