1// -Wall -Werror 2#pragma version(1) 3#pragma rs java_package_name(result) 4 5// This test case was created by ./gen-result.pl. 6// It exercises all legal Java-reflectable result types, so that we can ensure 7// (a) We do not choke when compiling them 8// (b) We reflect them correctly 9 10// One example struct type 11typedef struct MyStruct { float f; double d; } MyStruct; 12 13#pragma rs reduce(my_half) accumulator(my_half_accum) combiner(my_half_comb) 14static void my_half_accum(half *accum, half val) { } 15static void my_half_comb(half *accum, const half *other) { } 16 17#pragma rs reduce(my_half2) accumulator(my_half2_accum) combiner(my_half2_comb) 18static void my_half2_accum(half2 *accum, half2 val) { } 19static void my_half2_comb(half2 *accum, const half2 *other) { } 20 21#pragma rs reduce(my_half4) accumulator(my_half4_accum) combiner(my_half4_comb) 22static void my_half4_accum(half4 *accum, half4 val) { } 23static void my_half4_comb(half4 *accum, const half4 *other) { } 24 25#pragma rs reduce(my_array_half) accumulator(my_array_half_accum) combiner(my_array_half_comb) 26typedef half array_half[7]; 27static void my_array_half_accum(array_half *accum, half val) { } 28static void my_array_half_comb(array_half *accum, const array_half *other) { } 29 30#pragma rs reduce(my_array_half2) accumulator(my_array_half2_accum) combiner(my_array_half2_comb) 31typedef half2 array_half2[7]; 32static void my_array_half2_accum(array_half2 *accum, half2 val) { } 33static void my_array_half2_comb(array_half2 *accum, const array_half2 *other) { } 34 35#pragma rs reduce(my_array_half4) accumulator(my_array_half4_accum) combiner(my_array_half4_comb) 36typedef half4 array_half4[7]; 37static void my_array_half4_accum(array_half4 *accum, half4 val) { } 38static void my_array_half4_comb(array_half4 *accum, const array_half4 *other) { } 39 40#pragma rs reduce(my_float) accumulator(my_float_accum) combiner(my_float_comb) 41static void my_float_accum(float *accum, float val) { } 42static void my_float_comb(float *accum, const float *other) { } 43 44#pragma rs reduce(my_float2) accumulator(my_float2_accum) combiner(my_float2_comb) 45static void my_float2_accum(float2 *accum, float2 val) { } 46static void my_float2_comb(float2 *accum, const float2 *other) { } 47 48#pragma rs reduce(my_float4) accumulator(my_float4_accum) combiner(my_float4_comb) 49static void my_float4_accum(float4 *accum, float4 val) { } 50static void my_float4_comb(float4 *accum, const float4 *other) { } 51 52#pragma rs reduce(my_array_float) accumulator(my_array_float_accum) combiner(my_array_float_comb) 53typedef float array_float[7]; 54static void my_array_float_accum(array_float *accum, float val) { } 55static void my_array_float_comb(array_float *accum, const array_float *other) { } 56 57#pragma rs reduce(my_array_float2) accumulator(my_array_float2_accum) combiner(my_array_float2_comb) 58typedef float2 array_float2[7]; 59static void my_array_float2_accum(array_float2 *accum, float2 val) { } 60static void my_array_float2_comb(array_float2 *accum, const array_float2 *other) { } 61 62#pragma rs reduce(my_array_float4) accumulator(my_array_float4_accum) combiner(my_array_float4_comb) 63typedef float4 array_float4[7]; 64static void my_array_float4_accum(array_float4 *accum, float4 val) { } 65static void my_array_float4_comb(array_float4 *accum, const array_float4 *other) { } 66 67#pragma rs reduce(my_double) accumulator(my_double_accum) combiner(my_double_comb) 68static void my_double_accum(double *accum, double val) { } 69static void my_double_comb(double *accum, const double *other) { } 70 71#pragma rs reduce(my_double2) accumulator(my_double2_accum) combiner(my_double2_comb) 72static void my_double2_accum(double2 *accum, double2 val) { } 73static void my_double2_comb(double2 *accum, const double2 *other) { } 74 75#pragma rs reduce(my_double4) accumulator(my_double4_accum) combiner(my_double4_comb) 76static void my_double4_accum(double4 *accum, double4 val) { } 77static void my_double4_comb(double4 *accum, const double4 *other) { } 78 79#pragma rs reduce(my_array_double) accumulator(my_array_double_accum) combiner(my_array_double_comb) 80typedef double array_double[7]; 81static void my_array_double_accum(array_double *accum, double val) { } 82static void my_array_double_comb(array_double *accum, const array_double *other) { } 83 84#pragma rs reduce(my_array_double2) accumulator(my_array_double2_accum) combiner(my_array_double2_comb) 85typedef double2 array_double2[7]; 86static void my_array_double2_accum(array_double2 *accum, double2 val) { } 87static void my_array_double2_comb(array_double2 *accum, const array_double2 *other) { } 88 89#pragma rs reduce(my_array_double4) accumulator(my_array_double4_accum) combiner(my_array_double4_comb) 90typedef double4 array_double4[7]; 91static void my_array_double4_accum(array_double4 *accum, double4 val) { } 92static void my_array_double4_comb(array_double4 *accum, const array_double4 *other) { } 93 94#pragma rs reduce(my_char) accumulator(my_char_accum) combiner(my_char_comb) 95static void my_char_accum(char *accum, char val) { } 96static void my_char_comb(char *accum, const char *other) { } 97 98#pragma rs reduce(my_char2) accumulator(my_char2_accum) combiner(my_char2_comb) 99static void my_char2_accum(char2 *accum, char2 val) { } 100static void my_char2_comb(char2 *accum, const char2 *other) { } 101 102#pragma rs reduce(my_char4) accumulator(my_char4_accum) combiner(my_char4_comb) 103static void my_char4_accum(char4 *accum, char4 val) { } 104static void my_char4_comb(char4 *accum, const char4 *other) { } 105 106#pragma rs reduce(my_array_char) accumulator(my_array_char_accum) combiner(my_array_char_comb) 107typedef char array_char[7]; 108static void my_array_char_accum(array_char *accum, char val) { } 109static void my_array_char_comb(array_char *accum, const array_char *other) { } 110 111#pragma rs reduce(my_array_char2) accumulator(my_array_char2_accum) combiner(my_array_char2_comb) 112typedef char2 array_char2[7]; 113static void my_array_char2_accum(array_char2 *accum, char2 val) { } 114static void my_array_char2_comb(array_char2 *accum, const array_char2 *other) { } 115 116#pragma rs reduce(my_array_char4) accumulator(my_array_char4_accum) combiner(my_array_char4_comb) 117typedef char4 array_char4[7]; 118static void my_array_char4_accum(array_char4 *accum, char4 val) { } 119static void my_array_char4_comb(array_char4 *accum, const array_char4 *other) { } 120 121#pragma rs reduce(my_short) accumulator(my_short_accum) combiner(my_short_comb) 122static void my_short_accum(short *accum, short val) { } 123static void my_short_comb(short *accum, const short *other) { } 124 125#pragma rs reduce(my_short2) accumulator(my_short2_accum) combiner(my_short2_comb) 126static void my_short2_accum(short2 *accum, short2 val) { } 127static void my_short2_comb(short2 *accum, const short2 *other) { } 128 129#pragma rs reduce(my_short4) accumulator(my_short4_accum) combiner(my_short4_comb) 130static void my_short4_accum(short4 *accum, short4 val) { } 131static void my_short4_comb(short4 *accum, const short4 *other) { } 132 133#pragma rs reduce(my_array_short) accumulator(my_array_short_accum) combiner(my_array_short_comb) 134typedef short array_short[7]; 135static void my_array_short_accum(array_short *accum, short val) { } 136static void my_array_short_comb(array_short *accum, const array_short *other) { } 137 138#pragma rs reduce(my_array_short2) accumulator(my_array_short2_accum) combiner(my_array_short2_comb) 139typedef short2 array_short2[7]; 140static void my_array_short2_accum(array_short2 *accum, short2 val) { } 141static void my_array_short2_comb(array_short2 *accum, const array_short2 *other) { } 142 143#pragma rs reduce(my_array_short4) accumulator(my_array_short4_accum) combiner(my_array_short4_comb) 144typedef short4 array_short4[7]; 145static void my_array_short4_accum(array_short4 *accum, short4 val) { } 146static void my_array_short4_comb(array_short4 *accum, const array_short4 *other) { } 147 148#pragma rs reduce(my_int) accumulator(my_int_accum) combiner(my_int_comb) 149static void my_int_accum(int *accum, int val) { } 150static void my_int_comb(int *accum, const int *other) { } 151 152#pragma rs reduce(my_int2) accumulator(my_int2_accum) combiner(my_int2_comb) 153static void my_int2_accum(int2 *accum, int2 val) { } 154static void my_int2_comb(int2 *accum, const int2 *other) { } 155 156#pragma rs reduce(my_int4) accumulator(my_int4_accum) combiner(my_int4_comb) 157static void my_int4_accum(int4 *accum, int4 val) { } 158static void my_int4_comb(int4 *accum, const int4 *other) { } 159 160#pragma rs reduce(my_array_int) accumulator(my_array_int_accum) combiner(my_array_int_comb) 161typedef int array_int[7]; 162static void my_array_int_accum(array_int *accum, int val) { } 163static void my_array_int_comb(array_int *accum, const array_int *other) { } 164 165#pragma rs reduce(my_array_int2) accumulator(my_array_int2_accum) combiner(my_array_int2_comb) 166typedef int2 array_int2[7]; 167static void my_array_int2_accum(array_int2 *accum, int2 val) { } 168static void my_array_int2_comb(array_int2 *accum, const array_int2 *other) { } 169 170#pragma rs reduce(my_array_int4) accumulator(my_array_int4_accum) combiner(my_array_int4_comb) 171typedef int4 array_int4[7]; 172static void my_array_int4_accum(array_int4 *accum, int4 val) { } 173static void my_array_int4_comb(array_int4 *accum, const array_int4 *other) { } 174 175#pragma rs reduce(my_long) accumulator(my_long_accum) combiner(my_long_comb) 176static void my_long_accum(long *accum, long val) { } 177static void my_long_comb(long *accum, const long *other) { } 178 179#pragma rs reduce(my_long2) accumulator(my_long2_accum) combiner(my_long2_comb) 180static void my_long2_accum(long2 *accum, long2 val) { } 181static void my_long2_comb(long2 *accum, const long2 *other) { } 182 183#pragma rs reduce(my_long4) accumulator(my_long4_accum) combiner(my_long4_comb) 184static void my_long4_accum(long4 *accum, long4 val) { } 185static void my_long4_comb(long4 *accum, const long4 *other) { } 186 187#pragma rs reduce(my_array_long) accumulator(my_array_long_accum) combiner(my_array_long_comb) 188typedef long array_long[7]; 189static void my_array_long_accum(array_long *accum, long val) { } 190static void my_array_long_comb(array_long *accum, const array_long *other) { } 191 192#pragma rs reduce(my_array_long2) accumulator(my_array_long2_accum) combiner(my_array_long2_comb) 193typedef long2 array_long2[7]; 194static void my_array_long2_accum(array_long2 *accum, long2 val) { } 195static void my_array_long2_comb(array_long2 *accum, const array_long2 *other) { } 196 197#pragma rs reduce(my_array_long4) accumulator(my_array_long4_accum) combiner(my_array_long4_comb) 198typedef long4 array_long4[7]; 199static void my_array_long4_accum(array_long4 *accum, long4 val) { } 200static void my_array_long4_comb(array_long4 *accum, const array_long4 *other) { } 201 202#pragma rs reduce(my_uchar) accumulator(my_uchar_accum) combiner(my_uchar_comb) 203static void my_uchar_accum(uchar *accum, uchar val) { } 204static void my_uchar_comb(uchar *accum, const uchar *other) { } 205 206#pragma rs reduce(my_uchar2) accumulator(my_uchar2_accum) combiner(my_uchar2_comb) 207static void my_uchar2_accum(uchar2 *accum, uchar2 val) { } 208static void my_uchar2_comb(uchar2 *accum, const uchar2 *other) { } 209 210#pragma rs reduce(my_uchar4) accumulator(my_uchar4_accum) combiner(my_uchar4_comb) 211static void my_uchar4_accum(uchar4 *accum, uchar4 val) { } 212static void my_uchar4_comb(uchar4 *accum, const uchar4 *other) { } 213 214#pragma rs reduce(my_array_uchar) accumulator(my_array_uchar_accum) combiner(my_array_uchar_comb) 215typedef uchar array_uchar[7]; 216static void my_array_uchar_accum(array_uchar *accum, uchar val) { } 217static void my_array_uchar_comb(array_uchar *accum, const array_uchar *other) { } 218 219#pragma rs reduce(my_array_uchar2) accumulator(my_array_uchar2_accum) combiner(my_array_uchar2_comb) 220typedef uchar2 array_uchar2[7]; 221static void my_array_uchar2_accum(array_uchar2 *accum, uchar2 val) { } 222static void my_array_uchar2_comb(array_uchar2 *accum, const array_uchar2 *other) { } 223 224#pragma rs reduce(my_array_uchar4) accumulator(my_array_uchar4_accum) combiner(my_array_uchar4_comb) 225typedef uchar4 array_uchar4[7]; 226static void my_array_uchar4_accum(array_uchar4 *accum, uchar4 val) { } 227static void my_array_uchar4_comb(array_uchar4 *accum, const array_uchar4 *other) { } 228 229#pragma rs reduce(my_ushort) accumulator(my_ushort_accum) combiner(my_ushort_comb) 230static void my_ushort_accum(ushort *accum, ushort val) { } 231static void my_ushort_comb(ushort *accum, const ushort *other) { } 232 233#pragma rs reduce(my_ushort2) accumulator(my_ushort2_accum) combiner(my_ushort2_comb) 234static void my_ushort2_accum(ushort2 *accum, ushort2 val) { } 235static void my_ushort2_comb(ushort2 *accum, const ushort2 *other) { } 236 237#pragma rs reduce(my_ushort4) accumulator(my_ushort4_accum) combiner(my_ushort4_comb) 238static void my_ushort4_accum(ushort4 *accum, ushort4 val) { } 239static void my_ushort4_comb(ushort4 *accum, const ushort4 *other) { } 240 241#pragma rs reduce(my_array_ushort) accumulator(my_array_ushort_accum) combiner(my_array_ushort_comb) 242typedef ushort array_ushort[7]; 243static void my_array_ushort_accum(array_ushort *accum, ushort val) { } 244static void my_array_ushort_comb(array_ushort *accum, const array_ushort *other) { } 245 246#pragma rs reduce(my_array_ushort2) accumulator(my_array_ushort2_accum) combiner(my_array_ushort2_comb) 247typedef ushort2 array_ushort2[7]; 248static void my_array_ushort2_accum(array_ushort2 *accum, ushort2 val) { } 249static void my_array_ushort2_comb(array_ushort2 *accum, const array_ushort2 *other) { } 250 251#pragma rs reduce(my_array_ushort4) accumulator(my_array_ushort4_accum) combiner(my_array_ushort4_comb) 252typedef ushort4 array_ushort4[7]; 253static void my_array_ushort4_accum(array_ushort4 *accum, ushort4 val) { } 254static void my_array_ushort4_comb(array_ushort4 *accum, const array_ushort4 *other) { } 255 256#pragma rs reduce(my_uint) accumulator(my_uint_accum) combiner(my_uint_comb) 257static void my_uint_accum(uint *accum, uint val) { } 258static void my_uint_comb(uint *accum, const uint *other) { } 259 260#pragma rs reduce(my_uint2) accumulator(my_uint2_accum) combiner(my_uint2_comb) 261static void my_uint2_accum(uint2 *accum, uint2 val) { } 262static void my_uint2_comb(uint2 *accum, const uint2 *other) { } 263 264#pragma rs reduce(my_uint4) accumulator(my_uint4_accum) combiner(my_uint4_comb) 265static void my_uint4_accum(uint4 *accum, uint4 val) { } 266static void my_uint4_comb(uint4 *accum, const uint4 *other) { } 267 268#pragma rs reduce(my_array_uint) accumulator(my_array_uint_accum) combiner(my_array_uint_comb) 269typedef uint array_uint[7]; 270static void my_array_uint_accum(array_uint *accum, uint val) { } 271static void my_array_uint_comb(array_uint *accum, const array_uint *other) { } 272 273#pragma rs reduce(my_array_uint2) accumulator(my_array_uint2_accum) combiner(my_array_uint2_comb) 274typedef uint2 array_uint2[7]; 275static void my_array_uint2_accum(array_uint2 *accum, uint2 val) { } 276static void my_array_uint2_comb(array_uint2 *accum, const array_uint2 *other) { } 277 278#pragma rs reduce(my_array_uint4) accumulator(my_array_uint4_accum) combiner(my_array_uint4_comb) 279typedef uint4 array_uint4[7]; 280static void my_array_uint4_accum(array_uint4 *accum, uint4 val) { } 281static void my_array_uint4_comb(array_uint4 *accum, const array_uint4 *other) { } 282 283#pragma rs reduce(my_ulong) accumulator(my_ulong_accum) combiner(my_ulong_comb) 284static void my_ulong_accum(ulong *accum, ulong val) { } 285static void my_ulong_comb(ulong *accum, const ulong *other) { } 286 287#pragma rs reduce(my_ulong2) accumulator(my_ulong2_accum) combiner(my_ulong2_comb) 288static void my_ulong2_accum(ulong2 *accum, ulong2 val) { } 289static void my_ulong2_comb(ulong2 *accum, const ulong2 *other) { } 290 291#pragma rs reduce(my_ulong4) accumulator(my_ulong4_accum) combiner(my_ulong4_comb) 292static void my_ulong4_accum(ulong4 *accum, ulong4 val) { } 293static void my_ulong4_comb(ulong4 *accum, const ulong4 *other) { } 294 295#pragma rs reduce(my_array_ulong) accumulator(my_array_ulong_accum) combiner(my_array_ulong_comb) 296typedef ulong array_ulong[7]; 297static void my_array_ulong_accum(array_ulong *accum, ulong val) { } 298static void my_array_ulong_comb(array_ulong *accum, const array_ulong *other) { } 299 300#pragma rs reduce(my_array_ulong2) accumulator(my_array_ulong2_accum) combiner(my_array_ulong2_comb) 301typedef ulong2 array_ulong2[7]; 302static void my_array_ulong2_accum(array_ulong2 *accum, ulong2 val) { } 303static void my_array_ulong2_comb(array_ulong2 *accum, const array_ulong2 *other) { } 304 305#pragma rs reduce(my_array_ulong4) accumulator(my_array_ulong4_accum) combiner(my_array_ulong4_comb) 306typedef ulong4 array_ulong4[7]; 307static void my_array_ulong4_accum(array_ulong4 *accum, ulong4 val) { } 308static void my_array_ulong4_comb(array_ulong4 *accum, const array_ulong4 *other) { } 309 310#pragma rs reduce(my_bool) accumulator(my_bool_accum) combiner(my_bool_comb) 311static void my_bool_accum(bool *accum, bool val) { } 312static void my_bool_comb(bool *accum, const bool *other) { } 313 314#pragma rs reduce(my_array_bool) accumulator(my_array_bool_accum) combiner(my_array_bool_comb) 315typedef bool array_bool[7]; 316static void my_array_bool_accum(array_bool *accum, bool val) { } 317static void my_array_bool_comb(array_bool *accum, const array_bool *other) { } 318 319#pragma rs reduce(my_MyStruct) accumulator(my_MyStruct_accum) combiner(my_MyStruct_comb) 320static void my_MyStruct_accum(MyStruct *accum, MyStruct val) { } 321static void my_MyStruct_comb(MyStruct *accum, const MyStruct *other) { } 322 323#pragma rs reduce(my_array_MyStruct) accumulator(my_array_MyStruct_accum) combiner(my_array_MyStruct_comb) 324typedef MyStruct array_MyStruct[7]; 325static void my_array_MyStruct_accum(array_MyStruct *accum, MyStruct val) { } 326static void my_array_MyStruct_comb(array_MyStruct *accum, const array_MyStruct *other) { } 327