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