pocl

Merge lp:~schnetter/pocl/main into lp:~pocl/pocl/trunk

  1. main
  2. Merge into trunk
Proposed by Erik Schnetter
Status: Merged
Merge reported by: Pekka Jääskeläinen
Merged at revision: not available
Proposed branch: lp:~schnetter/pocl/main
Merge into: lp:~pocl/pocl/trunk
Diff against target: 1318 lines (+318/-749)
10 files modified
include/_kernel.h (+80/-163)
include/arm/types.h (+7/-7)
include/tce/types.h (+7/-7)
include/types.h (+15/-15)
include/x86_64/types.h (+8/-8)
lib/kernel/as_type.cl (+73/-192)
lib/kernel/convert_type.cl (+114/-356)
lib/kernel/sources.mk (+2/-1)
lib/kernel/vload.cl (+6/-0)
lib/kernel/vstore.cl (+6/-0)
To merge this branch: bzr merge lp:~schnetter/pocl/main
Reviewer Review Type Date Requested Status
Pekka Jääskeläinen Pending
Review via email: mp+84163@code.launchpad.net

Description of the change

Cleanup

Simplify #ifdef and #defines in many spots; reduce code size.

To post a comment you must log in.
lp:~schnetter/pocl/main updated
93. By Erik Schnetter

Remove vec_step, which is already a Clang intrinsic

94. By Erik Schnetter

Merge from trunk

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'include/_kernel.h'
2--- include/_kernel.h 2011-11-29 16:59:14 +0000
3+++ include/_kernel.h 2011-12-04 22:04:24 +0000
4@@ -48,6 +48,9 @@
5 # define __IF_FP64(x)
6 #endif
7
8+/* A static assert statement to catch inconsistencies at build time */
9+#define _cl_static_assert(_t, _x) typedef int ai##_t[(_x) ? 1 : -1]
10+
11 #define __global __attribute__ ((address_space(3)))
12 #define __local __attribute__ ((address_space(4)))
13 #define __constant __attribute__ ((address_space(5)))
14@@ -64,6 +67,18 @@
15
16
17 /* Data types */
18
19+/* Disable undefined datatypes */
20+#ifndef cles_khr_int64
21+typedef struct error_undefined_type_long error_undefined_type_long;
22+# define long error_undefined_type_long
23+typedef struct error_undefined_type_ulong error_undefined_type_ulong;
24+# define ulong error_undefined_type_ulong
25+#endif
26+#ifndef cl_khr_fp64
27+typedef struct error_undefined_type_double error_undefined_type_double;
28+# define double error_undefined_type_double
29+#endif
30+
31 // We align the 3-vectors, so that their sizeof is correct. Is there a
32 // better way? Should we also align the other vectors?
33
34@@ -115,10 +130,6 @@
35 typedef ulong ulong4 __attribute__((__ext_vector_type__(4)));
36 typedef ulong ulong8 __attribute__((__ext_vector_type__(8)));
37 typedef ulong ulong16 __attribute__((__ext_vector_type__(16)));
38-#else
39-/* Disable datatype */
40-struct error_undefined_type_long;
41-#define long struct error_undefined_type_long
42 #endif
43
44 typedef float float2 __attribute__((__ext_vector_type__(2)));
45@@ -133,15 +144,9 @@
46 typedef double double4 __attribute__((__ext_vector_type__(4)));
47 typedef double double8 __attribute__((__ext_vector_type__(8)));
48 typedef double double16 __attribute__((__ext_vector_type__(16)));
49-#else
50-/* Disable datatype */
51-struct error_undefined_type_double;
52-#define double struct error_undefined_type_double
53 #endif
54
55 /* Ensure the data types have the right sizes */
56-#define _cl_static_assert(_t, _x) typedef int ai##_t[(_x) ? 1 : -1]
57-
58 _cl_static_assert(char , sizeof(char ) == 1);
59 _cl_static_assert(char2 , sizeof(char2 ) == 2 *sizeof(char));
60 _cl_static_assert(char3 , sizeof(char3 ) == 4 *sizeof(char));
61@@ -354,146 +359,62 @@
62 __IF_INT64(_CL_DECLARE_AS_TYPE_128(ulong16))
63 __IF_FP64(_CL_DECLARE_AS_TYPE_128(double16))
64
65-#define _CL_DECLARE_CONVERT_TYPE(SRC, DST) \
66- DST _cl_overloadable convert_##DST(SRC a);
67-
68-/* 1 element */
69-#define _CL_DECLARE_CONVERT_TYPE_1(SRC) \
70- _CL_DECLARE_CONVERT_TYPE(SRC, char) \
71- _CL_DECLARE_CONVERT_TYPE(SRC, uchar) \
72- _CL_DECLARE_CONVERT_TYPE(SRC, short) \
73- _CL_DECLARE_CONVERT_TYPE(SRC, ushort) \
74- _CL_DECLARE_CONVERT_TYPE(SRC, int) \
75- _CL_DECLARE_CONVERT_TYPE(SRC, uint) \
76- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long)) \
77- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong)) \
78- _CL_DECLARE_CONVERT_TYPE(SRC, float) \
79- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double))
80-_CL_DECLARE_CONVERT_TYPE_1(char)
81-_CL_DECLARE_CONVERT_TYPE_1(uchar)
82-_CL_DECLARE_CONVERT_TYPE_1(short)
83-_CL_DECLARE_CONVERT_TYPE_1(ushort)
84-_CL_DECLARE_CONVERT_TYPE_1(int)
85-_CL_DECLARE_CONVERT_TYPE_1(uint)
86-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_1(long))
87-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_1(ulong))
88-_CL_DECLARE_CONVERT_TYPE_1(float)
89-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_1(double))
90-
91-/* 2 elements */
92-#define _CL_DECLARE_CONVERT_TYPE_2(SRC) \
93- _CL_DECLARE_CONVERT_TYPE(SRC, char2) \
94- _CL_DECLARE_CONVERT_TYPE(SRC, uchar2) \
95- _CL_DECLARE_CONVERT_TYPE(SRC, short2) \
96- _CL_DECLARE_CONVERT_TYPE(SRC, ushort2) \
97- _CL_DECLARE_CONVERT_TYPE(SRC, int2) \
98- _CL_DECLARE_CONVERT_TYPE(SRC, uint2) \
99- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long2)) \
100- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong2)) \
101- _CL_DECLARE_CONVERT_TYPE(SRC, float2) \
102- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double2))
103-_CL_DECLARE_CONVERT_TYPE_2(char2)
104-_CL_DECLARE_CONVERT_TYPE_2(uchar2)
105-_CL_DECLARE_CONVERT_TYPE_2(short2)
106-_CL_DECLARE_CONVERT_TYPE_2(ushort2)
107-_CL_DECLARE_CONVERT_TYPE_2(int2)
108-_CL_DECLARE_CONVERT_TYPE_2(uint2)
109-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_2(long2))
110-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_2(ulong2))
111-_CL_DECLARE_CONVERT_TYPE_2(float2)
112-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_2(double2))
113-
114-/* 3 elements */
115-#define _CL_DECLARE_CONVERT_TYPE_3(SRC) \
116- _CL_DECLARE_CONVERT_TYPE(SRC, char3) \
117- _CL_DECLARE_CONVERT_TYPE(SRC, uchar3) \
118- _CL_DECLARE_CONVERT_TYPE(SRC, short3) \
119- _CL_DECLARE_CONVERT_TYPE(SRC, ushort3) \
120- _CL_DECLARE_CONVERT_TYPE(SRC, int3) \
121- _CL_DECLARE_CONVERT_TYPE(SRC, uint3) \
122- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long3)) \
123- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong3)) \
124- _CL_DECLARE_CONVERT_TYPE(SRC, float3) \
125- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double3))
126-_CL_DECLARE_CONVERT_TYPE_3(char3)
127-_CL_DECLARE_CONVERT_TYPE_3(uchar3)
128-_CL_DECLARE_CONVERT_TYPE_3(short3)
129-_CL_DECLARE_CONVERT_TYPE_3(ushort3)
130-_CL_DECLARE_CONVERT_TYPE_3(int3)
131-_CL_DECLARE_CONVERT_TYPE_3(uint3)
132-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_3(long3))
133-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_3(ulong3))
134-_CL_DECLARE_CONVERT_TYPE_3(float3)
135-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_3(double3))
136-
137-/* 4 elements */
138-#define _CL_DECLARE_CONVERT_TYPE_4(SRC) \
139- _CL_DECLARE_CONVERT_TYPE(SRC, char4) \
140- _CL_DECLARE_CONVERT_TYPE(SRC, uchar4) \
141- _CL_DECLARE_CONVERT_TYPE(SRC, short4) \
142- _CL_DECLARE_CONVERT_TYPE(SRC, ushort4) \
143- _CL_DECLARE_CONVERT_TYPE(SRC, int4) \
144- _CL_DECLARE_CONVERT_TYPE(SRC, uint4) \
145- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long4)) \
146- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong4)) \
147- _CL_DECLARE_CONVERT_TYPE(SRC, float4) \
148- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double4))
149-_CL_DECLARE_CONVERT_TYPE_4(char4)
150-_CL_DECLARE_CONVERT_TYPE_4(uchar4)
151-_CL_DECLARE_CONVERT_TYPE_4(short4)
152-_CL_DECLARE_CONVERT_TYPE_4(ushort4)
153-_CL_DECLARE_CONVERT_TYPE_4(int4)
154-_CL_DECLARE_CONVERT_TYPE_4(uint4)
155-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_4(long4))
156-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_4(ulong4))
157-_CL_DECLARE_CONVERT_TYPE_4(float4)
158-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_4(double4))
159-
160-/* 8 elements */
161-#define _CL_DECLARE_CONVERT_TYPE_8(SRC) \
162- _CL_DECLARE_CONVERT_TYPE(SRC, char8) \
163- _CL_DECLARE_CONVERT_TYPE(SRC, uchar8) \
164- _CL_DECLARE_CONVERT_TYPE(SRC, short8) \
165- _CL_DECLARE_CONVERT_TYPE(SRC, ushort8) \
166- _CL_DECLARE_CONVERT_TYPE(SRC, int8) \
167- _CL_DECLARE_CONVERT_TYPE(SRC, uint8) \
168- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long8)) \
169- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong8)) \
170- _CL_DECLARE_CONVERT_TYPE(SRC, float8) \
171- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double8))
172-_CL_DECLARE_CONVERT_TYPE_8(char8)
173-_CL_DECLARE_CONVERT_TYPE_8(uchar8)
174-_CL_DECLARE_CONVERT_TYPE_8(short8)
175-_CL_DECLARE_CONVERT_TYPE_8(ushort8)
176-_CL_DECLARE_CONVERT_TYPE_8(int8)
177-_CL_DECLARE_CONVERT_TYPE_8(uint8)
178-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_8(long8))
179-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_8(ulong8))
180-_CL_DECLARE_CONVERT_TYPE_8(float8)
181-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_8(double8))
182-
183-/* 16 elements */
184-#define _CL_DECLARE_CONVERT_TYPE_16(SRC) \
185- _CL_DECLARE_CONVERT_TYPE(SRC, char16) \
186- _CL_DECLARE_CONVERT_TYPE(SRC, uchar16) \
187- _CL_DECLARE_CONVERT_TYPE(SRC, short16) \
188- _CL_DECLARE_CONVERT_TYPE(SRC, ushort16) \
189- _CL_DECLARE_CONVERT_TYPE(SRC, int16) \
190- _CL_DECLARE_CONVERT_TYPE(SRC, uint16) \
191- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, long16)) \
192- __IF_INT64(_CL_DECLARE_CONVERT_TYPE(SRC, ulong16)) \
193- _CL_DECLARE_CONVERT_TYPE(SRC, float16) \
194- __IF_FP64(_CL_DECLARE_CONVERT_TYPE(SRC, double16))
195-_CL_DECLARE_CONVERT_TYPE_16(char16)
196-_CL_DECLARE_CONVERT_TYPE_16(uchar16)
197-_CL_DECLARE_CONVERT_TYPE_16(short16)
198-_CL_DECLARE_CONVERT_TYPE_16(ushort16)
199-_CL_DECLARE_CONVERT_TYPE_16(int16)
200-_CL_DECLARE_CONVERT_TYPE_16(uint16)
201-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_16(long16))
202-__IF_INT64(_CL_DECLARE_CONVERT_TYPE_16(ulong16))
203-_CL_DECLARE_CONVERT_TYPE_16(float16)
204-__IF_FP64(_CL_DECLARE_CONVERT_TYPE_16(double16))
205+#define _CL_DECLARE_CONVERT_TYPE(SRC, DST, SIZE, INTSUFFIX, FLOATSUFFIX) \
206+ DST##SIZE _cl_overloadable \
207+ convert_##DST##SIZE##INTSUFFIX##FLOATSUFFIX(SRC##SIZE a);
208+
209+/* conversions to int may have a suffix: _sat */
210+#define _CL_DECLARE_CONVERT_TYPE_DST(SRC, SIZE, FLOATSUFFIX) \
211+ _CL_DECLARE_CONVERT_TYPE(SRC, char , SIZE, , FLOATSUFFIX) \
212+ _CL_DECLARE_CONVERT_TYPE(SRC, char , SIZE, _sat, FLOATSUFFIX) \
213+ _CL_DECLARE_CONVERT_TYPE(SRC, uchar , SIZE, , FLOATSUFFIX) \
214+ _CL_DECLARE_CONVERT_TYPE(SRC, uchar , SIZE, _sat, FLOATSUFFIX) \
215+ _CL_DECLARE_CONVERT_TYPE(SRC, short , SIZE, , FLOATSUFFIX) \
216+ _CL_DECLARE_CONVERT_TYPE(SRC, short , SIZE, _sat, FLOATSUFFIX) \
217+ _CL_DECLARE_CONVERT_TYPE(SRC, ushort, SIZE, , FLOATSUFFIX) \
218+ _CL_DECLARE_CONVERT_TYPE(SRC, ushort, SIZE, _sat, FLOATSUFFIX) \
219+ _CL_DECLARE_CONVERT_TYPE(SRC, int , SIZE, , FLOATSUFFIX) \
220+ _CL_DECLARE_CONVERT_TYPE(SRC, int , SIZE, _sat, FLOATSUFFIX) \
221+ _CL_DECLARE_CONVERT_TYPE(SRC, uint , SIZE, , FLOATSUFFIX) \
222+ _CL_DECLARE_CONVERT_TYPE(SRC, uint , SIZE, _sat, FLOATSUFFIX) \
223+ __IF_INT64( \
224+ _CL_DECLARE_CONVERT_TYPE(SRC, long , SIZE, , FLOATSUFFIX) \
225+ _CL_DECLARE_CONVERT_TYPE(SRC, long , SIZE, _sat, FLOATSUFFIX) \
226+ _CL_DECLARE_CONVERT_TYPE(SRC, ulong , SIZE, , FLOATSUFFIX) \
227+ _CL_DECLARE_CONVERT_TYPE(SRC, ulong , SIZE, _sat, FLOATSUFFIX)) \
228+ _CL_DECLARE_CONVERT_TYPE(SRC, float , SIZE, , FLOATSUFFIX) \
229+ __IF_FP64( \
230+ _CL_DECLARE_CONVERT_TYPE(SRC, double, SIZE, , FLOATSUFFIX))
231+
232+/* conversions from float may have a suffix: _rte _rtz _rtp _rtn */
233+#define _CL_DECLARE_CONVERT_TYPE_SRC_DST(SIZE) \
234+ _CL_DECLARE_CONVERT_TYPE_DST(char , SIZE, ) \
235+ _CL_DECLARE_CONVERT_TYPE_DST(uchar , SIZE, ) \
236+ _CL_DECLARE_CONVERT_TYPE_DST(short , SIZE, ) \
237+ _CL_DECLARE_CONVERT_TYPE_DST(ushort, SIZE, ) \
238+ _CL_DECLARE_CONVERT_TYPE_DST(int , SIZE, ) \
239+ _CL_DECLARE_CONVERT_TYPE_DST(uint , SIZE, ) \
240+ __IF_INT64( \
241+ _CL_DECLARE_CONVERT_TYPE_DST(long , SIZE, ) \
242+ _CL_DECLARE_CONVERT_TYPE_DST(ulong , SIZE, )) \
243+ _CL_DECLARE_CONVERT_TYPE_DST(float , SIZE, ) \
244+ _CL_DECLARE_CONVERT_TYPE_DST(float , SIZE, _rte) \
245+ _CL_DECLARE_CONVERT_TYPE_DST(float , SIZE, _rtz) \
246+ _CL_DECLARE_CONVERT_TYPE_DST(float , SIZE, _rtp) \
247+ _CL_DECLARE_CONVERT_TYPE_DST(float , SIZE, _rtn) \
248+ __IF_FP64( \
249+ _CL_DECLARE_CONVERT_TYPE_DST(double, SIZE, ) \
250+ _CL_DECLARE_CONVERT_TYPE_DST(double, SIZE, _rte) \
251+ _CL_DECLARE_CONVERT_TYPE_DST(double, SIZE, _rtz) \
252+ _CL_DECLARE_CONVERT_TYPE_DST(double, SIZE, _rtp) \
253+ _CL_DECLARE_CONVERT_TYPE_DST(double, SIZE, _rtn))
254+
255+_CL_DECLARE_CONVERT_TYPE_SRC_DST( )
256+_CL_DECLARE_CONVERT_TYPE_SRC_DST( 2)
257+_CL_DECLARE_CONVERT_TYPE_SRC_DST( 3)
258+_CL_DECLARE_CONVERT_TYPE_SRC_DST( 4)
259+_CL_DECLARE_CONVERT_TYPE_SRC_DST( 8)
260+_CL_DECLARE_CONVERT_TYPE_SRC_DST(16)
261
262
263
264 /* Work-Item Functions */
265@@ -668,13 +589,13 @@
266 float4 _cl_overloadable NAME(float4 , float4 , int4 ); \
267 float8 _cl_overloadable NAME(float8 , float8 , int8 ); \
268 float16 _cl_overloadable NAME(float16 , float16 , int16 ); \
269- __IF_INT64(__IF_FP64( \
270+ __IF_FP64( \
271 double _cl_overloadable NAME(double , double , long ); \
272 double2 _cl_overloadable NAME(double2 , double2 , long2 ); \
273 double3 _cl_overloadable NAME(double3 , double3 , long3 ); \
274 double4 _cl_overloadable NAME(double4 , double4 , long4 ); \
275 double8 _cl_overloadable NAME(double8 , double8 , long8 ); \
276- double16 _cl_overloadable NAME(double16, double16, long16);))
277+ double16 _cl_overloadable NAME(double16, double16, long16);)
278 #define _CL_DECLARE_FUNC_V_U(NAME) \
279 float _cl_overloadable NAME(uint ); \
280 float2 _cl_overloadable NAME(uint2 ); \
281@@ -682,13 +603,13 @@
282 float4 _cl_overloadable NAME(uint4 ); \
283 float8 _cl_overloadable NAME(uint8 ); \
284 float16 _cl_overloadable NAME(uint16 ); \
285- __IF_INT64(__IF_FP64( \
286+ __IF_FP64( \
287 double _cl_overloadable NAME(ulong ); \
288 double2 _cl_overloadable NAME(ulong2 ); \
289 double3 _cl_overloadable NAME(ulong3 ); \
290 double4 _cl_overloadable NAME(ulong4 ); \
291 double8 _cl_overloadable NAME(ulong8 ); \
292- double16 _cl_overloadable NAME(ulong16);))
293+ double16 _cl_overloadable NAME(ulong16);)
294 #define _CL_DECLARE_FUNC_V_VS(NAME) \
295 float2 _cl_overloadable NAME(float2 , float ); \
296 float3 _cl_overloadable NAME(float3 , float ); \
297@@ -724,12 +645,11 @@
298 int16 _cl_overloadable NAME(float16 , float16 ); \
299 __IF_FP64( \
300 int _cl_overloadable NAME(double , double ); \
301- __IF_INT64( \
302 long2 _cl_overloadable NAME(double2 , double2 ); \
303 long3 _cl_overloadable NAME(double3 , double3 ); \
304 long4 _cl_overloadable NAME(double4 , double4 ); \
305 long8 _cl_overloadable NAME(double8 , double8 ); \
306- long16 _cl_overloadable NAME(double16, double16);))
307+ long16 _cl_overloadable NAME(double16, double16);)
308 #define _CL_DECLARE_FUNC_V_VI(NAME) \
309 float2 _cl_overloadable NAME(float2 , int); \
310 float3 _cl_overloadable NAME(float3 , int); \
311@@ -1572,13 +1492,6 @@
312
313
314 /* Miscellaneous Vector Functions */
315
316-// convert a vector type to a scalar type
317-_CL_DECLARE_FUNC_I_IG(_cl_scalar)
318-_CL_DECLARE_FUNC_S_V(_cl_scalar)
319-#define vec_step(a) (sizeof(a) / sizeof(_cl_scalar(a)))
320-
321-
322-
323 // This code leads to an ICE in Clang
324
325 // #define _CL_DECLARE_SHUFFLE_2(GTYPE, UGTYPE, STYPE, M) \
326@@ -1693,3 +1606,7 @@
327 // _CL_DECLARE_SHUFFLE(double, ulong , double, 16)
328
329 // shuffle2
330+
331+
332
333+/* printf */
334+// int printf(constant char * restrict format, ...);
335
336=== modified file 'include/arm/types.h'
337--- include/arm/types.h 2011-11-29 16:59:14 +0000
338+++ include/arm/types.h 2011-12-04 22:04:24 +0000
339@@ -1,12 +1,12 @@
340-#define uchar unsigned char
341-#define ushort unsigned short
342-#define uint unsigned int
343+typedef unsigned char uchar;
344+typedef unsigned short ushort;
345+typedef unsigned int uint;
346
347 #define __EMBEDDED_PROFILE__ 1
348 #undef cles_khr_int64
349 #undef cl_khr_fp64
350
351-#define size_t uint
352-#define ptrdiff_t int
353-#define intptr_t int
354-#define uintptr_t uint
355+typedef uint size_t;
356+typedef int ptrdiff_t;
357+typedef int intptr_t;
358+typedef uint uintptr_t;
359
360=== modified file 'include/tce/types.h'
361--- include/tce/types.h 2011-11-29 16:59:14 +0000
362+++ include/tce/types.h 2011-12-04 22:04:24 +0000
363@@ -1,12 +1,12 @@
364-#define uchar unsigned char
365-#define ushort unsigned short
366-#define uint unsigned int
367+typedef unsigned char uchar;
368+typedef unsigned short ushort;
369+typedef unsigned int uint;
370
371 #define __EMBEDDED_PROFILE__ 1
372 #undef cles_khr_int64
373 #undef cl_khr_fp64
374
375-#define size_t uint
376-#define ptrdiff_t int
377-#define intptr_t int
378-#define uintptr_t uint
379+typedef uint size_t;
380+typedef int ptrdiff_t;
381+typedef int intptr_t;
382+typedef uint uintptr_t;
383
384=== modified file 'include/types.h'
385--- include/types.h 2011-11-29 19:13:26 +0000
386+++ include/types.h 2011-12-04 22:04:24 +0000
387@@ -6,23 +6,23 @@
388
389 #include "clconfig.h"
390
391-#define uchar unsigned char
392-#define ushort unsigned short
393-#define uint unsigned int
394-#define ulong unsigned long
395+typedef unsigned char uchar;
396+typedef unsigned short ushort;
397+typedef unsigned int uint;
398+typedef unsigned long ulong;
399
400 #if SIZEOF_LONG == 8
401-#define cles_khr_int64
402-#if SIZEOF_DOUBLE == 8
403-#define cl_khr_fp64
404-#else
405-#undef cl_khr_fp64
406-#endif
407-#else /* SIZEOF_LONG == 8 */
408-#define __EMBEDDED_PROFILE__ 1
409-#undef cles_khr_int64
410-#undef cl_khr_fp64
411-#endif /* SIZEOF_LONG == 8 */
412+# define cles_khr_int64
413+# if SIZEOF_DOUBLE == 8
414+# define cl_khr_fp64
415+# else
416+# undef cl_khr_fp64
417+# endif
418+#else /* SIZEOF_LONG != 8 */
419+# define __EMBEDDED_PROFILE__ 1
420+# undef cles_khr_int64
421+# undef cl_khr_fp64
422+#endif /* SIZEOF_LONG != 8 */
423
424 #if SIZEOF_VOID_P == 8
425 typedef ulong size_t;
426
427=== modified file 'include/x86_64/types.h'
428--- include/x86_64/types.h 2011-11-29 16:59:14 +0000
429+++ include/x86_64/types.h 2011-12-04 22:04:24 +0000
430@@ -1,12 +1,12 @@
431-#define uchar unsigned char
432-#define ushort unsigned short
433-#define uint unsigned int
434-#define ulong unsigned long
435+typedef unsigned char uchar;
436+typedef unsigned shor ushort;
437+typedef unsigned int uint;
438+typedef unsigned long ulong;
439
440 #define cles_khr_int64
441 #define cl_khr_fp64
442
443-#define size_t ulong
444-#define ptrdiff_t long
445-#define intptr_t long
446-#define uintptr_t ulong
447+typedef ulong size_t;
448+typedef long ptrdiff_t;
449+typedef long intptr_t;
450+typedef ulong uintptr_t;
451
452=== modified file 'lib/kernel/as_type.cl'
453--- lib/kernel/as_type.cl 2011-11-24 15:56:10 +0000
454+++ lib/kernel/as_type.cl 2011-12-04 22:04:24 +0000
455@@ -22,7 +22,7 @@
456 */
457
458 #define DEFINE_AS_TYPE(SRC, DST) \
459- DST __attribute__ ((__overloadable__)) \
460+ DST __attribute__ ((__overloadable__)) \
461 as_##DST(SRC a) \
462 { \
463 return *(DST*)&a; \
464@@ -72,49 +72,19 @@
465
466 /* 8 bytes */
467
468-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
469-#define DEFINE_AS_TYPE_8(DST) \
470- DEFINE_AS_TYPE(DST, char8) \
471- DEFINE_AS_TYPE(DST, uchar8) \
472- DEFINE_AS_TYPE(DST, short4) \
473- DEFINE_AS_TYPE(DST, ushort4) \
474- DEFINE_AS_TYPE(DST, int2) \
475- DEFINE_AS_TYPE(DST, uint2) \
476- DEFINE_AS_TYPE(DST, long) \
477- DEFINE_AS_TYPE(DST, ulong) \
478- DEFINE_AS_TYPE(DST, float2) \
479- DEFINE_AS_TYPE(DST, double)
480-#elif defined(cles_khr_int64)
481-#define DEFINE_AS_TYPE_8(DST) \
482- DEFINE_AS_TYPE(DST, char8) \
483- DEFINE_AS_TYPE(DST, uchar8) \
484- DEFINE_AS_TYPE(DST, short4) \
485- DEFINE_AS_TYPE(DST, ushort4) \
486- DEFINE_AS_TYPE(DST, int2) \
487- DEFINE_AS_TYPE(DST, uint2) \
488- DEFINE_AS_TYPE(DST, long) \
489- DEFINE_AS_TYPE(DST, ulong) \
490- DEFINE_AS_TYPE(DST, float2)
491-#elif defined(cl_khr_fp64)
492-#define DEFINE_AS_TYPE_8(DST) \
493- DEFINE_AS_TYPE(DST, char8) \
494- DEFINE_AS_TYPE(DST, uchar8) \
495- DEFINE_AS_TYPE(DST, short4) \
496- DEFINE_AS_TYPE(DST, ushort4) \
497- DEFINE_AS_TYPE(DST, int2) \
498- DEFINE_AS_TYPE(DST, uint2) \
499- DEFINE_AS_TYPE(DST, float2) \
500- DEFINE_AS_TYPE(DST, double)
501-#else
502-#define DEFINE_AS_TYPE_8(DST) \
503- DEFINE_AS_TYPE(DST, char8) \
504- DEFINE_AS_TYPE(DST, uchar8) \
505- DEFINE_AS_TYPE(DST, short4) \
506- DEFINE_AS_TYPE(DST, ushort4) \
507- DEFINE_AS_TYPE(DST, int2) \
508- DEFINE_AS_TYPE(DST, uint2) \
509- DEFINE_AS_TYPE(DST, float2)
510-#endif
511+#define DEFINE_AS_TYPE_8(DST) \
512+ DEFINE_AS_TYPE(DST, char8) \
513+ DEFINE_AS_TYPE(DST, uchar8) \
514+ DEFINE_AS_TYPE(DST, short4) \
515+ DEFINE_AS_TYPE(DST, ushort4) \
516+ DEFINE_AS_TYPE(DST, int2) \
517+ DEFINE_AS_TYPE(DST, uint2) \
518+ __IF_INT64( \
519+ DEFINE_AS_TYPE(DST, long) \
520+ DEFINE_AS_TYPE(DST, ulong)) \
521+ DEFINE_AS_TYPE(DST, float2) \
522+ __IF_FP64( \
523+ DEFINE_AS_TYPE(DST, double))
524
525 DEFINE_AS_TYPE_8(char8)
526 DEFINE_AS_TYPE_8(uchar8)
527@@ -122,60 +92,28 @@
528 DEFINE_AS_TYPE_8(ushort4)
529 DEFINE_AS_TYPE_8(int2)
530 DEFINE_AS_TYPE_8(uint2)
531-#ifdef cles_khr_int64
532+__IF_INT64(
533 DEFINE_AS_TYPE_8(long)
534-DEFINE_AS_TYPE_8(ulong)
535-#endif
536+DEFINE_AS_TYPE_8(ulong))
537 DEFINE_AS_TYPE_8(float2)
538-#ifdef cl_khr_fp64
539-DEFINE_AS_TYPE_8(double)
540-#endif
541+__IF_FP64(
542+DEFINE_AS_TYPE_8(double))
543
544 /* 16 bytes */
545
546-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
547-#define DEFINE_AS_TYPE_16(DST) \
548- DEFINE_AS_TYPE(DST, char16) \
549- DEFINE_AS_TYPE(DST, uchar16) \
550- DEFINE_AS_TYPE(DST, short8) \
551- DEFINE_AS_TYPE(DST, ushort8) \
552- DEFINE_AS_TYPE(DST, int4) \
553- DEFINE_AS_TYPE(DST, uint4) \
554- DEFINE_AS_TYPE(DST, long2) \
555- DEFINE_AS_TYPE(DST, ulong2) \
556- DEFINE_AS_TYPE(DST, float4) \
557- DEFINE_AS_TYPE(DST, double2)
558-#elif defined(cles_khr_int64)
559-#define DEFINE_AS_TYPE_16(DST) \
560- DEFINE_AS_TYPE(DST, char16) \
561- DEFINE_AS_TYPE(DST, uchar16) \
562- DEFINE_AS_TYPE(DST, short8) \
563- DEFINE_AS_TYPE(DST, ushort8) \
564- DEFINE_AS_TYPE(DST, int4) \
565- DEFINE_AS_TYPE(DST, uint4) \
566- DEFINE_AS_TYPE(DST, long2) \
567- DEFINE_AS_TYPE(DST, ulong2) \
568- DEFINE_AS_TYPE(DST, float4)
569-#elif defined(cl_khr_fp64)
570-#define DEFINE_AS_TYPE_16(DST) \
571- DEFINE_AS_TYPE(DST, char16) \
572- DEFINE_AS_TYPE(DST, uchar16) \
573- DEFINE_AS_TYPE(DST, short8) \
574- DEFINE_AS_TYPE(DST, ushort8) \
575- DEFINE_AS_TYPE(DST, int4) \
576- DEFINE_AS_TYPE(DST, uint4) \
577- DEFINE_AS_TYPE(DST, float4) \
578- DEFINE_AS_TYPE(DST, double2)
579-#else
580-#define DEFINE_AS_TYPE_16(DST) \
581- DEFINE_AS_TYPE(DST, char16) \
582- DEFINE_AS_TYPE(DST, uchar16) \
583- DEFINE_AS_TYPE(DST, short8) \
584- DEFINE_AS_TYPE(DST, ushort8) \
585- DEFINE_AS_TYPE(DST, int4) \
586- DEFINE_AS_TYPE(DST, uint4) \
587- DEFINE_AS_TYPE(DST, float4)
588-#endif
589+#define DEFINE_AS_TYPE_16(DST) \
590+ DEFINE_AS_TYPE(DST, char16) \
591+ DEFINE_AS_TYPE(DST, uchar16) \
592+ DEFINE_AS_TYPE(DST, short8) \
593+ DEFINE_AS_TYPE(DST, ushort8) \
594+ DEFINE_AS_TYPE(DST, int4) \
595+ DEFINE_AS_TYPE(DST, uint4) \
596+ __IF_INT64( \
597+ DEFINE_AS_TYPE(DST, long2) \
598+ DEFINE_AS_TYPE(DST, ulong2)) \
599+ DEFINE_AS_TYPE(DST, float4) \
600+ __IF_FP64( \
601+ DEFINE_AS_TYPE(DST, double2))
602
603 DEFINE_AS_TYPE_16(char16)
604 DEFINE_AS_TYPE_16(uchar16)
605@@ -183,127 +121,70 @@
606 DEFINE_AS_TYPE_16(ushort8)
607 DEFINE_AS_TYPE_16(int4)
608 DEFINE_AS_TYPE_16(uint4)
609-#ifdef cles_khr_int64
610+__IF_INT64(
611 DEFINE_AS_TYPE_16(long2)
612-DEFINE_AS_TYPE_16(ulong2)
613-#endif
614+DEFINE_AS_TYPE_16(ulong2))
615 DEFINE_AS_TYPE_16(float4)
616-#ifdef cl_khr_fp64
617-DEFINE_AS_TYPE_16(double2)
618-#endif
619+__IF_FP64(
620+DEFINE_AS_TYPE_16(double2))
621
622 /* 32 bytes */
623
624-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
625-#define DEFINE_AS_TYPE_32(DST) \
626- DEFINE_AS_TYPE(DST, short16) \
627- DEFINE_AS_TYPE(DST, ushort16) \
628- DEFINE_AS_TYPE(DST, int8) \
629- DEFINE_AS_TYPE(DST, uint8) \
630- DEFINE_AS_TYPE(DST, long4) \
631- DEFINE_AS_TYPE(DST, ulong4) \
632- DEFINE_AS_TYPE(DST, float8) \
633- DEFINE_AS_TYPE(DST, double4)
634-#elif defined(cles_khr_int64)
635-#define DEFINE_AS_TYPE_32(DST) \
636- DEFINE_AS_TYPE(DST, short16) \
637- DEFINE_AS_TYPE(DST, ushort16) \
638- DEFINE_AS_TYPE(DST, int8) \
639- DEFINE_AS_TYPE(DST, uint8) \
640- DEFINE_AS_TYPE(DST, long4) \
641- DEFINE_AS_TYPE(DST, ulong4) \
642- DEFINE_AS_TYPE(DST, float8)
643-#elif defined(cl_khr_fp64)
644-#define DEFINE_AS_TYPE_32(DST) \
645- DEFINE_AS_TYPE(DST, short16) \
646- DEFINE_AS_TYPE(DST, ushort16) \
647- DEFINE_AS_TYPE(DST, int8) \
648- DEFINE_AS_TYPE(DST, uint8) \
649- DEFINE_AS_TYPE(DST, float8) \
650- DEFINE_AS_TYPE(DST, double4)
651-#else
652-#define DEFINE_AS_TYPE_32(DST) \
653- DEFINE_AS_TYPE(DST, short16) \
654- DEFINE_AS_TYPE(DST, ushort16) \
655- DEFINE_AS_TYPE(DST, int8) \
656- DEFINE_AS_TYPE(DST, uint8) \
657- DEFINE_AS_TYPE(DST, float8)
658-#endif
659+#define DEFINE_AS_TYPE_32(DST) \
660+ DEFINE_AS_TYPE(DST, short16) \
661+ DEFINE_AS_TYPE(DST, ushort16) \
662+ DEFINE_AS_TYPE(DST, int8) \
663+ DEFINE_AS_TYPE(DST, uint8) \
664+ __IF_INT64( \
665+ DEFINE_AS_TYPE(DST, long4) \
666+ DEFINE_AS_TYPE(DST, ulong4)) \
667+ DEFINE_AS_TYPE(DST, float8) \
668+ __IF_FP64( \
669+ DEFINE_AS_TYPE(DST, double4))
670
671 DEFINE_AS_TYPE_32(short16)
672 DEFINE_AS_TYPE_32(ushort16)
673 DEFINE_AS_TYPE_32(int8)
674 DEFINE_AS_TYPE_32(uint8)
675-#ifdef cles_khr_int64
676+__IF_INT64(
677 DEFINE_AS_TYPE_32(long4)
678-DEFINE_AS_TYPE_32(ulong4)
679-#endif
680+DEFINE_AS_TYPE_32(ulong4))
681 DEFINE_AS_TYPE_32(float8)
682-#ifdef cl_khr_fp64
683-DEFINE_AS_TYPE_32(double4)
684-#endif
685+__IF_FP64(
686+DEFINE_AS_TYPE_32(double4))
687
688 /* 64 bytes */
689
690-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
691-#define DEFINE_AS_TYPE_64(DST) \
692- DEFINE_AS_TYPE(DST, int16) \
693- DEFINE_AS_TYPE(DST, uint16) \
694- DEFINE_AS_TYPE(DST, long8) \
695- DEFINE_AS_TYPE(DST, ulong8) \
696- DEFINE_AS_TYPE(DST, float16) \
697- DEFINE_AS_TYPE(DST, double8)
698-#elif defined(cles_khr_int64)
699-#define DEFINE_AS_TYPE_64(DST) \
700- DEFINE_AS_TYPE(DST, int16) \
701- DEFINE_AS_TYPE(DST, uint16) \
702- DEFINE_AS_TYPE(DST, long8) \
703- DEFINE_AS_TYPE(DST, ulong8) \
704- DEFINE_AS_TYPE(DST, float16)
705-#elif defined(cl_khr_fp64)
706-#define DEFINE_AS_TYPE_64(DST) \
707- DEFINE_AS_TYPE(DST, int16) \
708- DEFINE_AS_TYPE(DST, uint16) \
709- DEFINE_AS_TYPE(DST, float16) \
710- DEFINE_AS_TYPE(DST, double8)
711-#else
712-#define DEFINE_AS_TYPE_64(DST) \
713- DEFINE_AS_TYPE(DST, int16) \
714- DEFINE_AS_TYPE(DST, uint16) \
715- DEFINE_AS_TYPE(DST, float16)
716-#endif
717+#define DEFINE_AS_TYPE_64(DST) \
718+ DEFINE_AS_TYPE(DST, int16) \
719+ DEFINE_AS_TYPE(DST, uint16) \
720+ __IF_INT64( \
721+ DEFINE_AS_TYPE(DST, long8) \
722+ DEFINE_AS_TYPE(DST, ulong8)) \
723+ DEFINE_AS_TYPE(DST, float16) \
724+ __IF_FP64( \
725+ DEFINE_AS_TYPE(DST, double8))
726
727 DEFINE_AS_TYPE_64(int16)
728 DEFINE_AS_TYPE_64(uint16)
729-#ifdef cles_khr_int64
730+__IF_INT64(
731 DEFINE_AS_TYPE_64(long8)
732-DEFINE_AS_TYPE_64(ulong8)
733-#endif
734+DEFINE_AS_TYPE_64(ulong8))
735 DEFINE_AS_TYPE_64(float16)
736-#ifdef cl_khr_fp64
737-DEFINE_AS_TYPE_64(double8)
738-#endif
739+__IF_FP64(
740+DEFINE_AS_TYPE_64(double8))
741
742 /* 128 bytes */
743
744-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
745-#define DEFINE_AS_TYPE_128(DST) \
746- DEFINE_AS_TYPE(DST, long16) \
747- DEFINE_AS_TYPE(DST, ulong16) \
748- DEFINE_AS_TYPE(DST, double16)
749-#elif defined(cles_khr_int64)
750-#define DEFINE_AS_TYPE_128(DST) \
751- DEFINE_AS_TYPE(DST, long16) \
752- DEFINE_AS_TYPE(DST, ulong16)
753-#elif defined(cl_khr_fp64)
754-#define DEFINE_AS_TYPE_128(DST) \
755- DEFINE_AS_TYPE(DST, double16)
756-#endif
757+#define DEFINE_AS_TYPE_128(DST) \
758+ __IF_INT64( \
759+ DEFINE_AS_TYPE(DST, long16) \
760+ DEFINE_AS_TYPE(DST, ulong16)) \
761+ __IF_FP64( \
762+ DEFINE_AS_TYPE(DST, double16))
763
764-#ifdef cles_khr_int64
765+__IF_INT64(
766 DEFINE_AS_TYPE_128(long16)
767-DEFINE_AS_TYPE_128(ulong16)
768-#endif
769-#ifdef cl_khr_fp64
770-DEFINE_AS_TYPE_128(double16)
771-#endif
772+DEFINE_AS_TYPE_128(ulong16))
773+__IF_FP64(
774+DEFINE_AS_TYPE_128(double16))
775
776=== modified file 'lib/kernel/convert_type.cl'
777--- lib/kernel/convert_type.cl 2011-11-24 15:56:10 +0000
778+++ lib/kernel/convert_type.cl 2011-12-04 22:04:24 +0000
779@@ -23,374 +23,132 @@
780
781 #include "templates.h"
782
783+/* SRC and DST must be scalars */
784 #define DEFINE_CONVERT_TYPE(SRC, DST) \
785- DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
786+ DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
787 { \
788 return (DST)a; \
789 }
790
791+/* implementing vector SRC and DST in terms of scalars */
792 #define DEFINE_CONVERT_TYPE_HALF(SRC, DST, HALFDST) \
793- DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
794+ DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
795 { \
796 return (DST)(convert_##HALFDST(a.lo), convert_##HALFDST(a.hi)); \
797 }
798
799 #define DEFINE_CONVERT_TYPE_012(SRC, DST, DST01, DST2) \
800- DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
801+ DST __attribute__ ((__overloadable__)) convert_##DST(SRC a) \
802 { \
803 return (DST)(convert_##DST01(a.s01), convert_##DST2(a.s2)); \
804 }
805
806-/* 1 element */
807-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
808-#define DEFINE_CONVERT_TYPE_1(SRC) \
809- DEFINE_CONVERT_TYPE(SRC, char ) \
810- DEFINE_CONVERT_TYPE(SRC, uchar ) \
811- DEFINE_CONVERT_TYPE(SRC, short ) \
812- DEFINE_CONVERT_TYPE(SRC, ushort) \
813- DEFINE_CONVERT_TYPE(SRC, int ) \
814- DEFINE_CONVERT_TYPE(SRC, uint ) \
815- DEFINE_CONVERT_TYPE(SRC, long ) \
816- DEFINE_CONVERT_TYPE(SRC, ulong ) \
817- DEFINE_CONVERT_TYPE(SRC, float ) \
818- DEFINE_CONVERT_TYPE(SRC, double)
819-#elif defined(cles_khr_int64)
820-#define DEFINE_CONVERT_TYPE_1(SRC) \
821- DEFINE_CONVERT_TYPE(SRC, char ) \
822- DEFINE_CONVERT_TYPE(SRC, uchar ) \
823- DEFINE_CONVERT_TYPE(SRC, short ) \
824- DEFINE_CONVERT_TYPE(SRC, ushort) \
825- DEFINE_CONVERT_TYPE(SRC, int ) \
826- DEFINE_CONVERT_TYPE(SRC, uint ) \
827- DEFINE_CONVERT_TYPE(SRC, long ) \
828- DEFINE_CONVERT_TYPE(SRC, ulong ) \
829- DEFINE_CONVERT_TYPE(SRC, float )
830-#elif defined(cl_khr_fp64)
831-#define DEFINE_CONVERT_TYPE_1(SRC) \
832- DEFINE_CONVERT_TYPE(SRC, char ) \
833- DEFINE_CONVERT_TYPE(SRC, uchar ) \
834- DEFINE_CONVERT_TYPE(SRC, short ) \
835- DEFINE_CONVERT_TYPE(SRC, ushort) \
836- DEFINE_CONVERT_TYPE(SRC, int ) \
837- DEFINE_CONVERT_TYPE(SRC, uint ) \
838- DEFINE_CONVERT_TYPE(SRC, float ) \
839- DEFINE_CONVERT_TYPE(SRC, double)
840-#else
841-#define DEFINE_CONVERT_TYPE_1(SRC) \
842- DEFINE_CONVERT_TYPE(SRC, char ) \
843- DEFINE_CONVERT_TYPE(SRC, uchar ) \
844- DEFINE_CONVERT_TYPE(SRC, short ) \
845- DEFINE_CONVERT_TYPE(SRC, ushort) \
846- DEFINE_CONVERT_TYPE(SRC, int ) \
847- DEFINE_CONVERT_TYPE(SRC, uint ) \
848- DEFINE_CONVERT_TYPE(SRC, float )
849-#endif
850-DEFINE_CONVERT_TYPE_1(char )
851-DEFINE_CONVERT_TYPE_1(uchar )
852-DEFINE_CONVERT_TYPE_1(short )
853-DEFINE_CONVERT_TYPE_1(ushort)
854-DEFINE_CONVERT_TYPE_1(int )
855-DEFINE_CONVERT_TYPE_1(uint )
856-#ifdef cles_khr_int64
857-DEFINE_CONVERT_TYPE_1(long )
858-DEFINE_CONVERT_TYPE_1(ulong )
859-#endif
860-DEFINE_CONVERT_TYPE_1(float )
861-#ifdef cl_khr_fp64
862-DEFINE_CONVERT_TYPE_1(double)
863-#endif
864-
865-/* 2 elements */
866-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
867-#define DEFINE_CONVERT_TYPE_2(SRC) \
868- DEFINE_CONVERT_TYPE_HALF(SRC, char2 , char ) \
869- DEFINE_CONVERT_TYPE_HALF(SRC, uchar2 , uchar ) \
870- DEFINE_CONVERT_TYPE_HALF(SRC, short2 , short ) \
871- DEFINE_CONVERT_TYPE_HALF(SRC, ushort2, ushort) \
872- DEFINE_CONVERT_TYPE_HALF(SRC, int2 , int ) \
873- DEFINE_CONVERT_TYPE_HALF(SRC, uint2 , uint ) \
874- DEFINE_CONVERT_TYPE_HALF(SRC, long2 , long ) \
875- DEFINE_CONVERT_TYPE_HALF(SRC, ulong2 , ulong ) \
876- DEFINE_CONVERT_TYPE_HALF(SRC, float2 , float ) \
877- DEFINE_CONVERT_TYPE_HALF(SRC, double2, double)
878-#elif defined(cles_khr_int64)
879-#define DEFINE_CONVERT_TYPE_2(SRC) \
880- DEFINE_CONVERT_TYPE_HALF(SRC, char2 , char ) \
881- DEFINE_CONVERT_TYPE_HALF(SRC, uchar2 , uchar ) \
882- DEFINE_CONVERT_TYPE_HALF(SRC, short2 , short ) \
883- DEFINE_CONVERT_TYPE_HALF(SRC, ushort2, ushort) \
884- DEFINE_CONVERT_TYPE_HALF(SRC, int2 , int ) \
885- DEFINE_CONVERT_TYPE_HALF(SRC, uint2 , uint ) \
886- DEFINE_CONVERT_TYPE_HALF(SRC, long2 , long ) \
887- DEFINE_CONVERT_TYPE_HALF(SRC, ulong2 , ulong ) \
888- DEFINE_CONVERT_TYPE_HALF(SRC, float2 , float )
889-#elif defined(cl_khr_fp64)
890-#define DEFINE_CONVERT_TYPE_2(SRC) \
891- DEFINE_CONVERT_TYPE_HALF(SRC, char2 , char ) \
892- DEFINE_CONVERT_TYPE_HALF(SRC, uchar2 , uchar ) \
893- DEFINE_CONVERT_TYPE_HALF(SRC, short2 , short ) \
894- DEFINE_CONVERT_TYPE_HALF(SRC, ushort2, ushort) \
895- DEFINE_CONVERT_TYPE_HALF(SRC, int2 , int ) \
896- DEFINE_CONVERT_TYPE_HALF(SRC, uint2 , uint ) \
897- DEFINE_CONVERT_TYPE_HALF(SRC, float2 , float ) \
898- DEFINE_CONVERT_TYPE_HALF(SRC, double2, double)
899-#else
900-#define DEFINE_CONVERT_TYPE_2(SRC) \
901- DEFINE_CONVERT_TYPE_HALF(SRC, char2 , char ) \
902- DEFINE_CONVERT_TYPE_HALF(SRC, uchar2 , uchar ) \
903- DEFINE_CONVERT_TYPE_HALF(SRC, short2 , short ) \
904- DEFINE_CONVERT_TYPE_HALF(SRC, ushort2, ushort) \
905- DEFINE_CONVERT_TYPE_HALF(SRC, int2 , int ) \
906- DEFINE_CONVERT_TYPE_HALF(SRC, uint2 , uint ) \
907- DEFINE_CONVERT_TYPE_HALF(SRC, float2 , float )
908-#endif
909-DEFINE_CONVERT_TYPE_2(char2 )
910-DEFINE_CONVERT_TYPE_2(uchar2 )
911-DEFINE_CONVERT_TYPE_2(short2 )
912-DEFINE_CONVERT_TYPE_2(ushort2)
913-DEFINE_CONVERT_TYPE_2(int2 )
914-DEFINE_CONVERT_TYPE_2(uint2 )
915-#ifdef cl_kht_int64
916-DEFINE_CONVERT_TYPE_2(long2 )
917-DEFINE_CONVERT_TYPE_2(ulong2 )
918-#endif
919-DEFINE_CONVERT_TYPE_2(float2 )
920-#ifdef cl_khr_fp64
921-DEFINE_CONVERT_TYPE_2(double2)
922-#endif
923-
924-/* 3 elements */
925-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
926-#define DEFINE_CONVERT_TYPE_3(SRC) \
927- DEFINE_CONVERT_TYPE_012(SRC, char3 , char2 , char ) \
928- DEFINE_CONVERT_TYPE_012(SRC, uchar3 , uchar2 , uchar ) \
929- DEFINE_CONVERT_TYPE_012(SRC, short3 , short2 , short ) \
930- DEFINE_CONVERT_TYPE_012(SRC, ushort3, ushort2, ushort) \
931- DEFINE_CONVERT_TYPE_012(SRC, int3 , int2 , int ) \
932- DEFINE_CONVERT_TYPE_012(SRC, uint3 , uint2 , uint ) \
933- DEFINE_CONVERT_TYPE_012(SRC, long3 , long2 , long ) \
934- DEFINE_CONVERT_TYPE_012(SRC, ulong3 , ulong2 , ulong ) \
935- DEFINE_CONVERT_TYPE_012(SRC, float3 , float2 , float ) \
936- DEFINE_CONVERT_TYPE_012(SRC, double3, double2, double)
937-#elif defined(cles_khr_int64)
938-#define DEFINE_CONVERT_TYPE_3(SRC) \
939- DEFINE_CONVERT_TYPE_012(SRC, char3 , char2 , char ) \
940- DEFINE_CONVERT_TYPE_012(SRC, uchar3 , uchar2 , uchar ) \
941- DEFINE_CONVERT_TYPE_012(SRC, short3 , short2 , short ) \
942- DEFINE_CONVERT_TYPE_012(SRC, ushort3, ushort2, ushort) \
943- DEFINE_CONVERT_TYPE_012(SRC, int3 , int2 , int ) \
944- DEFINE_CONVERT_TYPE_012(SRC, uint3 , uint2 , uint ) \
945- DEFINE_CONVERT_TYPE_012(SRC, long3 , long2 , long ) \
946- DEFINE_CONVERT_TYPE_012(SRC, ulong3 , ulong2 , ulong ) \
947- DEFINE_CONVERT_TYPE_012(SRC, float3 , float2 , float )
948-#elif defined(cl_khr_fp64)
949-#define DEFINE_CONVERT_TYPE_3(SRC) \
950- DEFINE_CONVERT_TYPE_012(SRC, char3 , char2 , char ) \
951- DEFINE_CONVERT_TYPE_012(SRC, uchar3 , uchar2 , uchar ) \
952- DEFINE_CONVERT_TYPE_012(SRC, short3 , short2 , short ) \
953- DEFINE_CONVERT_TYPE_012(SRC, ushort3, ushort2, ushort) \
954- DEFINE_CONVERT_TYPE_012(SRC, int3 , int2 , int ) \
955- DEFINE_CONVERT_TYPE_012(SRC, uint3 , uint2 , uint ) \
956- DEFINE_CONVERT_TYPE_012(SRC, float3 , float2 , float ) \
957- DEFINE_CONVERT_TYPE_012(SRC, double3, double2, double)
958-#else
959-#define DEFINE_CONVERT_TYPE_3(SRC) \
960- DEFINE_CONVERT_TYPE_012(SRC, char3 , char2 , char ) \
961- DEFINE_CONVERT_TYPE_012(SRC, uchar3 , uchar2 , uchar ) \
962- DEFINE_CONVERT_TYPE_012(SRC, short3 , short2 , short ) \
963- DEFINE_CONVERT_TYPE_012(SRC, ushort3, ushort2, ushort) \
964- DEFINE_CONVERT_TYPE_012(SRC, int3 , int2 , int ) \
965- DEFINE_CONVERT_TYPE_012(SRC, uint3 , uint2 , uint ) \
966- DEFINE_CONVERT_TYPE_012(SRC, float3 , float2 , float )
967-#endif
968-DEFINE_CONVERT_TYPE_3(char3 )
969-DEFINE_CONVERT_TYPE_3(uchar3 )
970-DEFINE_CONVERT_TYPE_3(short3 )
971-DEFINE_CONVERT_TYPE_3(ushort3)
972-DEFINE_CONVERT_TYPE_3(int3 )
973-DEFINE_CONVERT_TYPE_3(uint3 )
974-#ifdef cl_kht_int64
975-DEFINE_CONVERT_TYPE_3(long3 )
976-DEFINE_CONVERT_TYPE_3(ulong3 )
977-#endif
978-DEFINE_CONVERT_TYPE_3(float3 )
979-#ifdef cl_khr_fp64
980-DEFINE_CONVERT_TYPE_3(double3)
981-#endif
982-
983-/* 4 elements */
984-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
985-#define DEFINE_CONVERT_TYPE_4(SRC) \
986- DEFINE_CONVERT_TYPE_HALF(SRC, char4 , char2 ) \
987- DEFINE_CONVERT_TYPE_HALF(SRC, uchar4 , uchar2 ) \
988- DEFINE_CONVERT_TYPE_HALF(SRC, short4 , short2 ) \
989- DEFINE_CONVERT_TYPE_HALF(SRC, ushort4, ushort2) \
990- DEFINE_CONVERT_TYPE_HALF(SRC, int4 , int2 ) \
991- DEFINE_CONVERT_TYPE_HALF(SRC, uint4 , uint2 ) \
992- DEFINE_CONVERT_TYPE_HALF(SRC, long4 , long2 ) \
993- DEFINE_CONVERT_TYPE_HALF(SRC, ulong4 , ulong2 ) \
994- DEFINE_CONVERT_TYPE_HALF(SRC, float4 , float2 ) \
995- DEFINE_CONVERT_TYPE_HALF(SRC, double4, double2)
996-#elif defined(cles_khr_int64)
997-#define DEFINE_CONVERT_TYPE_4(SRC) \
998- DEFINE_CONVERT_TYPE_HALF(SRC, char4 , char2 ) \
999- DEFINE_CONVERT_TYPE_HALF(SRC, uchar4 , uchar2 ) \
1000- DEFINE_CONVERT_TYPE_HALF(SRC, short4 , short2 ) \
1001- DEFINE_CONVERT_TYPE_HALF(SRC, ushort4, ushort2) \
1002- DEFINE_CONVERT_TYPE_HALF(SRC, int4 , int2 ) \
1003- DEFINE_CONVERT_TYPE_HALF(SRC, uint4 , uint2 ) \
1004- DEFINE_CONVERT_TYPE_HALF(SRC, long4 , long2 ) \
1005- DEFINE_CONVERT_TYPE_HALF(SRC, ulong4 , ulong2 ) \
1006- DEFINE_CONVERT_TYPE_HALF(SRC, float4 , float2 )
1007-#elif defined(cl_khr_fp64)
1008-#define DEFINE_CONVERT_TYPE_4(SRC) \
1009- DEFINE_CONVERT_TYPE_HALF(SRC, char4 , char2 ) \
1010- DEFINE_CONVERT_TYPE_HALF(SRC, uchar4 , uchar2 ) \
1011- DEFINE_CONVERT_TYPE_HALF(SRC, short4 , short2 ) \
1012- DEFINE_CONVERT_TYPE_HALF(SRC, ushort4, ushort2) \
1013- DEFINE_CONVERT_TYPE_HALF(SRC, int4 , int2 ) \
1014- DEFINE_CONVERT_TYPE_HALF(SRC, uint4 , uint2 ) \
1015- DEFINE_CONVERT_TYPE_HALF(SRC, float4 , float2 ) \
1016- DEFINE_CONVERT_TYPE_HALF(SRC, double4, double2)
1017-#else
1018-#define DEFINE_CONVERT_TYPE_4(SRC) \
1019- DEFINE_CONVERT_TYPE_HALF(SRC, char4 , char2 ) \
1020- DEFINE_CONVERT_TYPE_HALF(SRC, uchar4 , uchar2 ) \
1021- DEFINE_CONVERT_TYPE_HALF(SRC, short4 , short2 ) \
1022- DEFINE_CONVERT_TYPE_HALF(SRC, ushort4, ushort2) \
1023- DEFINE_CONVERT_TYPE_HALF(SRC, int4 , int2 ) \
1024- DEFINE_CONVERT_TYPE_HALF(SRC, uint4 , uint2 ) \
1025- DEFINE_CONVERT_TYPE_HALF(SRC, float4 , float2 )
1026-#endif
1027-DEFINE_CONVERT_TYPE_4(char4 )
1028-DEFINE_CONVERT_TYPE_4(uchar4 )
1029-DEFINE_CONVERT_TYPE_4(short4 )
1030-DEFINE_CONVERT_TYPE_4(ushort4)
1031-DEFINE_CONVERT_TYPE_4(int4 )
1032-DEFINE_CONVERT_TYPE_4(uint4 )
1033-#ifdef cl_kht_int64
1034-DEFINE_CONVERT_TYPE_4(long4 )
1035-DEFINE_CONVERT_TYPE_4(ulong4 )
1036-#endif
1037-DEFINE_CONVERT_TYPE_4(float4 )
1038-#ifdef cl_khr_fp64
1039-DEFINE_CONVERT_TYPE_4(double4)
1040-#endif
1041-
1042-/* 8 elements */
1043-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
1044-#define DEFINE_CONVERT_TYPE_8(SRC) \
1045- DEFINE_CONVERT_TYPE_HALF(SRC, char8 , char4 ) \
1046- DEFINE_CONVERT_TYPE_HALF(SRC, uchar8 , uchar4 ) \
1047- DEFINE_CONVERT_TYPE_HALF(SRC, short8 , short4 ) \
1048- DEFINE_CONVERT_TYPE_HALF(SRC, ushort8, ushort4) \
1049- DEFINE_CONVERT_TYPE_HALF(SRC, int8 , int4 ) \
1050- DEFINE_CONVERT_TYPE_HALF(SRC, uint8 , uint4 ) \
1051- DEFINE_CONVERT_TYPE_HALF(SRC, long8 , long4 ) \
1052- DEFINE_CONVERT_TYPE_HALF(SRC, ulong8 , ulong4 ) \
1053- DEFINE_CONVERT_TYPE_HALF(SRC, float8 , float4 ) \
1054- DEFINE_CONVERT_TYPE_HALF(SRC, double8, double4)
1055-#elif defined(cles_khr_int64)
1056-#define DEFINE_CONVERT_TYPE_8(SRC) \
1057- DEFINE_CONVERT_TYPE_HALF(SRC, char8 , char4 ) \
1058- DEFINE_CONVERT_TYPE_HALF(SRC, uchar8 , uchar4 ) \
1059- DEFINE_CONVERT_TYPE_HALF(SRC, short8 , short4 ) \
1060- DEFINE_CONVERT_TYPE_HALF(SRC, ushort8, ushort4) \
1061- DEFINE_CONVERT_TYPE_HALF(SRC, int8 , int4 ) \
1062- DEFINE_CONVERT_TYPE_HALF(SRC, uint8 , uint4 ) \
1063- DEFINE_CONVERT_TYPE_HALF(SRC, long8 , long4 ) \
1064- DEFINE_CONVERT_TYPE_HALF(SRC, ulong8 , ulong4 ) \
1065- DEFINE_CONVERT_TYPE_HALF(SRC, float8 , float4 )
1066-#elif defined(cl_khr_fp64)
1067-#define DEFINE_CONVERT_TYPE_8(SRC) \
1068- DEFINE_CONVERT_TYPE_HALF(SRC, char8 , char4 ) \
1069- DEFINE_CONVERT_TYPE_HALF(SRC, uchar8 , uchar4 ) \
1070- DEFINE_CONVERT_TYPE_HALF(SRC, short8 , short4 ) \
1071- DEFINE_CONVERT_TYPE_HALF(SRC, ushort8, ushort4) \
1072- DEFINE_CONVERT_TYPE_HALF(SRC, int8 , int4 ) \
1073- DEFINE_CONVERT_TYPE_HALF(SRC, uint8 , uint4 ) \
1074- DEFINE_CONVERT_TYPE_HALF(SRC, float8 , float4 ) \
1075- DEFINE_CONVERT_TYPE_HALF(SRC, double8, double4)
1076-#else
1077-#define DEFINE_CONVERT_TYPE_8(SRC) \
1078- DEFINE_CONVERT_TYPE_HALF(SRC, char8 , char4 ) \
1079- DEFINE_CONVERT_TYPE_HALF(SRC, uchar8 , uchar4 ) \
1080- DEFINE_CONVERT_TYPE_HALF(SRC, short8 , short4 ) \
1081- DEFINE_CONVERT_TYPE_HALF(SRC, ushort8, ushort4) \
1082- DEFINE_CONVERT_TYPE_HALF(SRC, int8 , int4 ) \
1083- DEFINE_CONVERT_TYPE_HALF(SRC, uint8 , uint4 ) \
1084- DEFINE_CONVERT_TYPE_HALF(SRC, float8 , float4 )
1085-#endif
1086-DEFINE_CONVERT_TYPE_8(char8 )
1087-DEFINE_CONVERT_TYPE_8(uchar8 )
1088-DEFINE_CONVERT_TYPE_8(short8 )
1089-DEFINE_CONVERT_TYPE_8(ushort8)
1090-DEFINE_CONVERT_TYPE_8(int8 )
1091-DEFINE_CONVERT_TYPE_8(uint8 )
1092-#ifdef cl_kht_int64
1093-DEFINE_CONVERT_TYPE_8(long8 )
1094-DEFINE_CONVERT_TYPE_8(ulong8 )
1095-#endif
1096-DEFINE_CONVERT_TYPE_8(float8 )
1097-#ifdef cl_khr_fp64
1098-DEFINE_CONVERT_TYPE_8(double8)
1099-#endif
1100-
1101-/* 16 elements */
1102-#if defined(cles_khr_int64) && defined(cl_khr_fp64)
1103-#define DEFINE_CONVERT_TYPE_16(SRC) \
1104- DEFINE_CONVERT_TYPE_HALF(SRC, char16 , char8 ) \
1105- DEFINE_CONVERT_TYPE_HALF(SRC, uchar16 , uchar8 ) \
1106- DEFINE_CONVERT_TYPE_HALF(SRC, short16 , short8 ) \
1107- DEFINE_CONVERT_TYPE_HALF(SRC, ushort16, ushort8) \
1108- DEFINE_CONVERT_TYPE_HALF(SRC, int16 , int8 ) \
1109- DEFINE_CONVERT_TYPE_HALF(SRC, uint16 , uint8 ) \
1110- DEFINE_CONVERT_TYPE_HALF(SRC, long16 , long8 ) \
1111- DEFINE_CONVERT_TYPE_HALF(SRC, ulong16 , ulong8 ) \
1112- DEFINE_CONVERT_TYPE_HALF(SRC, float16 , float8 ) \
1113- DEFINE_CONVERT_TYPE_HALF(SRC, double16, double8)
1114-#elif defined(cles_khr_int64)
1115-#define DEFINE_CONVERT_TYPE_16(SRC) \
1116- DEFINE_CONVERT_TYPE_HALF(SRC, char16 , char8 ) \
1117- DEFINE_CONVERT_TYPE_HALF(SRC, uchar16 , uchar8 ) \
1118- DEFINE_CONVERT_TYPE_HALF(SRC, short16 , short8 ) \
1119- DEFINE_CONVERT_TYPE_HALF(SRC, ushort16, ushort8) \
1120- DEFINE_CONVERT_TYPE_HALF(SRC, int16 , int8 ) \
1121- DEFINE_CONVERT_TYPE_HALF(SRC, uint16 , uint8 ) \
1122- DEFINE_CONVERT_TYPE_HALF(SRC, long16 , long8 ) \
1123- DEFINE_CONVERT_TYPE_HALF(SRC, ulong16 , ulong8 ) \
1124- DEFINE_CONVERT_TYPE_HALF(SRC, float16 , float8 )
1125-#elif defined(cl_khr_fp64)
1126-#define DEFINE_CONVERT_TYPE_16(SRC) \
1127- DEFINE_CONVERT_TYPE_HALF(SRC, char16 , char8 ) \
1128- DEFINE_CONVERT_TYPE_HALF(SRC, uchar16 , uchar8 ) \
1129- DEFINE_CONVERT_TYPE_HALF(SRC, short16 , short8 ) \
1130- DEFINE_CONVERT_TYPE_HALF(SRC, ushort16, ushort8) \
1131- DEFINE_CONVERT_TYPE_HALF(SRC, int16 , int8 ) \
1132- DEFINE_CONVERT_TYPE_HALF(SRC, uint16 , uint8 ) \
1133- DEFINE_CONVERT_TYPE_HALF(SRC, float16 , float8 ) \
1134- DEFINE_CONVERT_TYPE_HALF(SRC, double16, double8)
1135-#else
1136-#define DEFINE_CONVERT_TYPE_16(SRC) \
1137- DEFINE_CONVERT_TYPE_HALF(SRC, char16 , char8 ) \
1138- DEFINE_CONVERT_TYPE_HALF(SRC, uchar16 , uchar8 ) \
1139- DEFINE_CONVERT_TYPE_HALF(SRC, short16 , short8 ) \
1140- DEFINE_CONVERT_TYPE_HALF(SRC, ushort16, ushort8) \
1141- DEFINE_CONVERT_TYPE_HALF(SRC, int16 , int8 ) \
1142- DEFINE_CONVERT_TYPE_HALF(SRC, uint16 , uint8 ) \
1143- DEFINE_CONVERT_TYPE_HALF(SRC, float16 , float8 )
1144-#endif
1145-DEFINE_CONVERT_TYPE_16(char16 )
1146-DEFINE_CONVERT_TYPE_16(uchar16 )
1147-DEFINE_CONVERT_TYPE_16(short16 )
1148-DEFINE_CONVERT_TYPE_16(ushort16)
1149-DEFINE_CONVERT_TYPE_16(int16 )
1150-DEFINE_CONVERT_TYPE_16(uint16 )
1151-#ifdef cl_kht_int64
1152-DEFINE_CONVERT_TYPE_16(long16 )
1153-DEFINE_CONVERT_TYPE_16(ulong16 )
1154-#endif
1155-DEFINE_CONVERT_TYPE_16(float16 )
1156-#ifdef cl_khr_fp64
1157-DEFINE_CONVERT_TYPE_16(double16)
1158-#endif
1159+/* SRC and DST may be vectors */
1160+#define DEFINE_CONVERT_TYPE_SAT(SRC, DST, SIZE) \
1161+ DST##SIZE __attribute__ ((__overloadable__)) \
1162+ convert_##DST##SIZE##_sat(SRC##SIZE a) \
1163+ { \
1164+ int const src_float = (SRC)0.1f > (SRC)0; \
1165+ int const src_unsigned = -(SRC)1 > (SRC)0; \
1166+ int const dst_unsigned = -(DST)1 > (DST)0; \
1167+ int const src_size = sizeof(SRC); \
1168+ int const dst_size = sizeof(DST); \
1169+ if (src_float) { \
1170+ if (dst_unsigned) { \
1171+ DST const DST_MAX = (DST)0 - (DST)1; \
1172+ return (convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1173+ convert_##DST##SIZE(a)); \
1174+ } else { /* dst is signed */ \
1175+ DST const DST_MIN = (DST)1 << (DST)(CHAR_BIT * dst_size - 1); \
1176+ DST const DST_MAX = DST_MIN - (DST)1; \
1177+ return (convert_##DST##SIZE(a < (SRC)DST_MIN) ? (DST##SIZE)DST_MIN : \
1178+ convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1179+ convert_##DST##SIZE(a)); \
1180+ } \
1181+ } else if (src_unsigned) { \
1182+ if (dst_unsigned) { \
1183+ if (dst_size >= src_size) return convert_##DST##SIZE(a); \
1184+ DST const DST_MAX = (DST)0 - (DST)1; \
1185+ return (convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1186+ convert_##DST##SIZE(a)); \
1187+ } else { /* dst is signed */ \
1188+ if (dst_size > src_size) return convert_##DST##SIZE(a); \
1189+ DST const DST_MAX = (DST)1 << (DST)(CHAR_BIT * dst_size); \
1190+ return (convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1191+ convert_##DST##SIZE(a)); \
1192+ } \
1193+ } else { /* src is signed */ \
1194+ if (dst_unsigned) { \
1195+ if (dst_size >= src_size) { \
1196+ return (convert_##DST##SIZE(a < (SRC)0) ? (DST##SIZE)0 : \
1197+ convert_##DST##SIZE(a)); \
1198+ } \
1199+ DST const DST_MAX = (DST)0 - (DST)1; \
1200+ return (convert_##DST##SIZE(a < (SRC)0 ) ? (DST##SIZE)0 : \
1201+ convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1202+ convert_##DST##SIZE(a)); \
1203+ } else { /* dst is signed */ \
1204+ if (dst_size >= src_size) return convert_##DST##SIZE(a); \
1205+ DST const DST_MIN = (DST)1 << (DST)(CHAR_BIT * dst_size - 1); \
1206+ DST const DST_MAX = DST_MIN - (DST)1; \
1207+ return (convert_##DST##SIZE(a < (SRC)DST_MIN) ? (DST##SIZE)DST_MIN : \
1208+ convert_##DST##SIZE(a > (SRC)DST_MAX) ? (DST##SIZE)DST_MAX : \
1209+ convert_##DST##SIZE(a)); \
1210+ } \
1211+ } \
1212+ }
1213+
1214+
1215+
1216+#define DEFINE_CONVERT_TYPE_ALL(SRC, DST) \
1217+ DEFINE_CONVERT_TYPE (SRC , DST ) \
1218+ DEFINE_CONVERT_TYPE_HALF(SRC##2 , DST##2 , DST) \
1219+ DEFINE_CONVERT_TYPE_012 (SRC##3 , DST##3 , DST##2, DST) \
1220+ DEFINE_CONVERT_TYPE_HALF(SRC##4 , DST##4 , DST##2) \
1221+ DEFINE_CONVERT_TYPE_HALF(SRC##8 , DST##8 , DST##4) \
1222+ DEFINE_CONVERT_TYPE_HALF(SRC##16, DST##16, DST##8)
1223+
1224+#define DEFINE_CONVERT_TYPE_SAT_ALL(SRC, DST) \
1225+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, ) \
1226+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, 2) \
1227+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, 3) \
1228+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, 4) \
1229+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, 8) \
1230+ DEFINE_CONVERT_TYPE_SAT(SRC, DST, 16)
1231+
1232+
1233+
1234+#define DEFINE_CONVERT_TYPE_ALL_DST(SRC) \
1235+ DEFINE_CONVERT_TYPE_ALL (SRC, uchar ) \
1236+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, uchar ) \
1237+ DEFINE_CONVERT_TYPE_ALL (SRC, char ) \
1238+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, char ) \
1239+ DEFINE_CONVERT_TYPE_ALL (SRC, ushort) \
1240+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, ushort) \
1241+ DEFINE_CONVERT_TYPE_ALL (SRC, short ) \
1242+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, short ) \
1243+ DEFINE_CONVERT_TYPE_ALL (SRC, uint ) \
1244+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, uint ) \
1245+ DEFINE_CONVERT_TYPE_ALL (SRC, int ) \
1246+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, int ) \
1247+ __IF_INT64( \
1248+ DEFINE_CONVERT_TYPE_ALL (SRC, ulong ) \
1249+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, ulong ) \
1250+ DEFINE_CONVERT_TYPE_ALL (SRC, long ) \
1251+ DEFINE_CONVERT_TYPE_SAT_ALL(SRC, long )) \
1252+ DEFINE_CONVERT_TYPE_ALL (SRC, float ) \
1253+ __IF_FP64( \
1254+ DEFINE_CONVERT_TYPE_ALL (SRC, double))
1255+
1256+DEFINE_CONVERT_TYPE_ALL_DST(uchar )
1257+DEFINE_CONVERT_TYPE_ALL_DST(char )
1258+DEFINE_CONVERT_TYPE_ALL_DST(ushort)
1259+DEFINE_CONVERT_TYPE_ALL_DST(short )
1260+DEFINE_CONVERT_TYPE_ALL_DST(uint )
1261+DEFINE_CONVERT_TYPE_ALL_DST(int )
1262+__IF_INT64(
1263+DEFINE_CONVERT_TYPE_ALL_DST(ulong )
1264+DEFINE_CONVERT_TYPE_ALL_DST(long ))
1265+DEFINE_CONVERT_TYPE_ALL_DST(float )
1266+__IF_FP64(
1267+DEFINE_CONVERT_TYPE_ALL_DST(double))
1268
1269=== modified file 'lib/kernel/sources.mk'
1270--- lib/kernel/sources.mk 2011-11-08 18:34:25 +0000
1271+++ lib/kernel/sources.mk 2011-12-04 22:04:24 +0000
1272@@ -1,4 +1,5 @@
1273-libkernel_a_SOURCES = barrier.c \
1274+libkernel_a_SOURCES = templates.h \
1275+ barrier.c \
1276 get_global_size.c \
1277 get_global_id.c \
1278 get_local_id.c \
1279
1280=== modified file 'lib/kernel/vload.cl'
1281--- lib/kernel/vload.cl 2011-11-24 15:56:10 +0000
1282+++ lib/kernel/vload.cl 2011-12-04 22:04:24 +0000
1283@@ -108,11 +108,17 @@
1284 IMPLEMENT_VLOAD(char , __private)
1285 IMPLEMENT_VLOAD(short , __private)
1286 IMPLEMENT_VLOAD(int , __private)
1287+#if defined(cles_khr_int64)
1288 IMPLEMENT_VLOAD(long , __private)
1289+#endif
1290 IMPLEMENT_VLOAD(uchar , __private)
1291 IMPLEMENT_VLOAD(ushort, __private)
1292 IMPLEMENT_VLOAD(uint , __private)
1293+#if defined(cles_khr_int64)
1294 IMPLEMENT_VLOAD(ulong , __private)
1295+#endif
1296 IMPLEMENT_VLOAD(float , __private)
1297+#if defined(cl_khr_fp64)
1298 IMPLEMENT_VLOAD(double, __private)
1299+#endif
1300 */
1301
1302=== modified file 'lib/kernel/vstore.cl'
1303--- lib/kernel/vstore.cl 2011-11-24 15:56:10 +0000
1304+++ lib/kernel/vstore.cl 2011-12-04 22:04:24 +0000
1305@@ -98,11 +98,17 @@
1306 IMPLEMENT_VSTORE(char , __private)
1307 IMPLEMENT_VSTORE(short , __private)
1308 IMPLEMENT_VSTORE(int , __private)
1309+#if defined(cles_khr_int64)
1310 IMPLEMENT_VSTORE(long , __private)
1311+#endif
1312 IMPLEMENT_VSTORE(uchar , __private)
1313 IMPLEMENT_VSTORE(ushort, __private)
1314 IMPLEMENT_VSTORE(uint , __private)
1315+#if defined(cles_khr_int64)
1316 IMPLEMENT_VSTORE(ulong , __private)
1317+#endif
1318 IMPLEMENT_VSTORE(float , __private)
1319+#if defined(cl_khr_fpt64)
1320 IMPLEMENT_VSTORE(double, __private)
1321+#endif
1322 */