reduce_general_bad_result.rs revision 65f23ed862e1a1e16477ba740f295ff4a83ac822 
1// -target-api 0 -Wall
2#pragma version(1)
3#pragma rs java_package_name(export)
4
5// trivial accumulator for use multiple times later
6static void AccumInt(int *accum, int val) { }
7
8// NOTE: union and bitfield errors are only emitted once per type, so
9//       we have multiple types here to ensure that we issue errors
10//       in multiple contexts.
11
12// NOTE: accumulator data type is restricted in certain ways regardless
13//       of result type; we do not test that here.  This is covered
14//       in the test case reduce_general_bad_accumulator.rs.
15
16/////////////////////////////////////////////////////////////////////////
17
18// result type cannot be a vector of half
19#pragma rs reduce(redHalf3) accumulator(AccumHalf3)
20static void AccumHalf3(half3 *accum, half3 val) { }
21
22// problem is result type, not accumulator type, so outconverter can fix this
23#pragma rs reduce(redHalf3OutFix) accumulator(AccumHalf3) outconverter(OutHalf3Fix)
24static void OutHalf3Fix(half *out, const half3 *val) { }
25
26// problem is result type, not accumulator type, so outconverter can break this
27#pragma rs reduce(redHalf3OutBreak) accumulator(AccumInt) outconverter(OutHalf3Break)
28static void OutHalf3Break(half3 *out, const int *val) { }
29
30/////////////////////////////////////////////////////////////////////////
31
32typedef half4 Half4Array5[5];
33
34// result type cannot be an array of vector of half
35#pragma rs reduce(redHalf4A5) accumulator(AccumHalf4A5) combiner(CombHalf4A5)
36static void AccumHalf4A5(Half4Array5 *accum, short val) { }
37static void CombHalf4A5(Half4Array5 *accum, const Half4Array5 *other) { }
38
39// problem is result type, not accumulator type, so outconverter can fix this
40#pragma rs reduce(redHalf4A5OutFix) accumulator(AccumHalf4A5) combiner(CombHalf4A5) \
41  outconverter(OutHalf4A5Fix)
42static void OutHalf4A5Fix(half *out, const Half4Array5 *val) { }
43
44// problem is result type, not accumulator type, so outconverter can break this
45#pragma rs reduce(redHalf4A5OutBreak) accumulator(AccumInt) outconverter(OutHalf4A5Break)
46static void OutHalf4A5Break(Half4Array5 *out, const int *val) { }
47
48/////////////////////////////////////////////////////////////////////////
49
50typedef unsigned int UIntA916[9][16];
51
52// result type cannot be multidimensional array
53#pragma rs reduce(redUInt2dA) accumulator(AccumUInt2dA) combiner(CombUInt2dA)
54static void AccumUInt2dA(UIntA916 *accum, int val) { }
55static void CombUInt2dA(UIntA916 *accum, const UIntA916 *val) { }
56
57// problem is result type, not accumulator type, so outconverter can fix this
58#pragma rs reduce(redUInt2dAOutFix) accumulator(AccumUInt2dA) combiner(CombUInt2dA) \
59  outconverter(OutUInt2dAFix)
60static void OutUInt2dAFix(uint *out, const UIntA916 *val) { }
61
62// problem is result type, not accumulator type, so outconverter can break this
63#pragma rs reduce(redUInt2dAOutBreak) accumulator(AccumInt) outconverter(OutUInt2dABreak)
64static void OutUInt2dABreak(UIntA916 *out, const int *val) { }
65
66/////////////////////////////////////////////////////////////////////////
67
68union UnionShortDouble {
69  short s;
70  double d;
71};
72
73union UnionCharInt {
74  char c;
75  int i;
76};
77
78union UnionLongFloat {
79  long l;
80  float f;
81};
82
83// result type cannot be union
84#pragma rs reduce(redUnionShortDouble) accumulator(AccumUnionShortDouble) \
85  combiner(CombineUnionShortDouble)
86static void AccumUnionShortDouble(union UnionShortDouble *accum, short s, double d) { }
87static void CombineUnionShortDouble(union UnionShortDouble *accum,
88                                    const union UnionShortDouble *other) { }
89
90// problem is result type, not accumulator type, so outconverter can fix this
91#pragma rs reduce(redUnionCharIntOutFix) accumulator(AccumUnionCharInt) \
92  combiner(CombineUnionCharInt) outconverter(OutUnionCharIntFix)
93static void AccumUnionCharInt(union UnionCharInt *accum, short s, double d) { }
94static void CombineUnionCharInt(union UnionCharInt *accum, const union UnionCharInt *other) { }
95static void OutUnionCharIntFix(int *out, const union UnionCharInt *val) { }
96
97// problem is result type, not accumulator type, so outconverter can break this
98#pragma rs reduce(redUnionLongFloatOutBreak) accumulator(AccumInt) \
99  outconverter(OutUnionLongFloatBreak)
100static void OutUnionLongFloatBreak(union UnionLongFloat *out, const int *val) { }
101
102/////////////////////////////////////////////////////////////////////////
103
104union UnionIntFloat {
105  short s;
106  double d;
107};
108typedef union UnionIntFloat UnionIntFloatArray[10];
109
110union UnionDoubleFloat {
111  double d;
112  float f;
113};
114typedef union UnionDoubleFloat UnionDoubleFloatArray[10];
115
116union UnionCharLong {
117  char c;
118  long l;
119};
120typedef union UnionCharLong UnionCharLongArray[10];
121
122// cannot export array of union
123#pragma rs reduce(redUnionIntFloatArray) accumulator(AccumUnionIntFloatArray) \
124  combiner(CombineUnionIntFloatArray)
125static void AccumUnionIntFloatArray(UnionIntFloatArray *accum, int val) { }
126static void CombineUnionIntFloatArray(UnionIntFloatArray *accum,
127                                      const UnionIntFloatArray *other) { }
128
129// problem is result type, not accumulator type, so outconverter can fix this
130#pragma rs reduce(redUnionDoubleFloatArrayOutFix) accumulator(AccumUnionDoubleFloatArray) \
131  combiner(CombineUnionDoubleFloatArray) outconverter(OutUnionDoubleFloatArrayFix)
132static void AccumUnionDoubleFloatArray(UnionDoubleFloatArray *accum, short s, double d) { }
133static void CombineUnionDoubleFloatArray(UnionDoubleFloatArray *accum,
134                                           const UnionDoubleFloatArray *other) { }
135static void OutUnionDoubleFloatArrayFix(int *out, const UnionDoubleFloatArray *val) { }
136
137// problem is result type, not accumulator type, so outconverter can break this
138#pragma rs reduce(redUnionCharLongArrayOutBreak) accumulator(AccumInt) \
139  outconverter(OutUnionCharLongArrayBreak)
140static void OutUnionCharLongArrayBreak(UnionCharLongArray *out, const int *val) { }
141
142/////////////////////////////////////////////////////////////////////////
143
144struct Bits1 {
145  int b:1;
146};
147
148struct Bits11 {
149  int c:1;
150  int d:1;
151};
152
153struct Bits111 {
154  int e:1;
155  int f:1;
156  int g:1;
157};
158
159// cannot export struct with bitfield
160#pragma rs reduce(redBits) accumulator(AccumBits) combiner(CombineBits)
161static void AccumBits(struct Bits1 *accum, int val) { }
162static void CombineBits(struct Bits1 *accum, const struct Bits1 *other) { }
163
164// problem is result type, not accumulator type, so outconverter can fix this
165#pragma rs reduce(redBitsOutFix) accumulator(AccumBitsOutFix) combiner(CombineBitsOutFix) \
166  outconverter(OutBitsFix)
167static void AccumBitsOutFix(struct Bits11 *accum, int val) { }
168static void CombineBitsOutFix(struct Bits11 *accum, const struct Bits11 *other) { }
169static void OutBitsFix(int *out, const struct Bits11 *val) { }
170
171// problem is result type, not accumulator type, so outconverter can break this
172#pragma rs reduce(redBitsOutBreak) accumulator(AccumInt) outconverter(OutBitsBreak)
173static void OutBitsBreak(struct Bits111 *out, const int *val) { }
174
175/////////////////////////////////////////////////////////////////////////
176
177struct Bits2 {
178  int b:2;
179};
180typedef struct Bits2 Bits2Array[10];
181
182struct Bits22 {
183  int c:2;
184  int d:2;
185};
186typedef struct Bits22 Bits22Array[10];
187
188struct Bits222 {
189  int e:2;
190  int f:2;
191  int g:2;
192};
193typedef struct Bits222 Bits222Array[10];
194
195// cannot export array of struct with bitfield
196#pragma rs reduce(redBitsArray) accumulator(AccumBitsArray) combiner(CombineBitsArray)
197static void AccumBitsArray(Bits2Array *accum, int val) { }
198static void CombineBitsArray(Bits2Array *accum, const Bits2Array *other) { }
199
200// problem is result type, not accumulator type, so outconverter can fix this
201#pragma rs reduce(redBitsArrayOutFix) accumulator(AccumBitsArrayOutFix) \
202  combiner(CombineBitsArrayOutFix) outconverter(OutBitsArrayFix)
203static void AccumBitsArrayOutFix(Bits22Array *accum, int val) { }
204static void CombineBitsArrayOutFix(Bits22Array *accum, const Bits22Array *other) { }
205static void OutBitsArrayFix(int *out, const Bits22Array *val) { }
206
207// problem is result type, not accumulator type, so outconverter can break this
208#pragma rs reduce(redBitsArrayOutBreak) accumulator(AccumInt) outconverter(OutBitsArrayBreak)
209static void OutBitsArrayBreak(Bits222Array *out, const int *val) { }
210
211/////////////////////////////////////////////////////////////////////////
212
213// result type cannot be matrix
214#pragma rs reduce(redMat) accumulator(AccumMat)
215static void AccumMat(rs_matrix2x2 *accum, rs_matrix2x2 val) { }
216
217// problem is result type, not accumulator type, so outconverter can fix this
218#pragma rs reduce(redMatOutFix) accumulator(AccumMat) outconverter(OutMatFix)
219static void OutMatFix(int *out, const rs_matrix2x2 *val) { }
220
221// problem is result type, not accumulator type, so outconverter can break this
222#pragma rs reduce(redMatOutBreak) accumulator(AccumInt) outconverter(OutMatBreak)
223static void OutMatBreak(rs_matrix2x2 *out, const int *val) { }
224
225/////////////////////////////////////////////////////////////////////////
226
227typedef rs_matrix2x2 ArrayMatrix2x2[10];
228
229// result type cannot be array of matrix
230#pragma rs reduce(redMatArray) accumulator(AccumMatArray) combiner(CombineMatArray)
231static void AccumMatArray(ArrayMatrix2x2 *accum, rs_matrix2x2 val) { }
232static void CombineMatArray(ArrayMatrix2x2 *accum, const ArrayMatrix2x2 *other) { }
233
234// problem is result type, not accumulator type, so outconverter can fix this
235#pragma rs reduce(redMatArrayOutFix) accumulator(AccumMatArray) combiner(CombineMatArray) \
236  outconverter(OutMatArrayFix)
237static void OutMatArrayFix(int *out, const ArrayMatrix2x2 *val) { }
238
239// problem is result type, not accumulator type, so outconverter can break this
240#pragma rs reduce(redMatArrayOutBreak) accumulator(AccumInt) outconverter(OutMatArrayBreak)
241static void OutMatArrayBreak(ArrayMatrix2x2 *out, const int *val) { }
242
243/////////////////////////////////////////////////////////////////////////
244
245// result type cannot be object type
246#pragma rs reduce(redAlloc) accumulator(AccumInt) outconverter(OutAlloc)
247static void OutAlloc(rs_allocation *out, const int *val) { }
248
249/////////////////////////////////////////////////////////////////////////
250
251typedef rs_allocation AllocArray[10];
252
253// result type cannot be array of object type
254#pragma rs reduce(redAllocArray) accumulator(AccumAllocArray) outconverter(OutAllocArray)
255static void AccumAllocArray(int *accum, int val) { }
256static void OutAllocArray(AllocArray *out, const int *val) { }
257
258/////////////////////////////////////////////////////////////////////////
259
260struct StructObj1 {
261  int f;
262  rs_element e;
263};
264
265// result type cannot be struct containing object type
266#pragma rs reduce(redStructObj) accumulator(AccumStructObj) outconverter(OutStructObj)
267static void AccumStructObj(int *accum, int val) { }
268static void OutStructObj(struct StructObj1 *out, const int *val) { }
269
270/////////////////////////////////////////////////////////////////////////
271
272struct StructObj2 {
273  rs_type t;
274  float f;
275};
276typedef struct StructObj2 StructObj2Array[10];
277
278// result type cannot be array of struct containing object type
279#pragma rs reduce(redStructObjArray) accumulator(AccumStructObjArray) \
280  outconverter(OutStructObjArray)
281static void AccumStructObjArray(int *accum, int val) { }
282static void OutStructObjArray(StructObj2Array *out, const int *val) { }
283
284/////////////////////////////////////////////////////////////////////////
285
286typedef char *Ptr;
287
288// result type cannot be pointer
289#pragma rs reduce(redPtr) accumulator(AccumPtr) combiner(CombPtr)
290static void AccumPtr(Ptr *accum, char val) { }
291static void CombPtr(Ptr *accum, const Ptr *other) { }
292
293// problem is result type, not accumulator type, so outconverter can fix this
294#pragma rs reduce(redPtrOutFix) accumulator(AccumPtr) combiner(CombPtr) \
295  outconverter(OutPtrFix)
296static void OutPtrFix(int *out, const Ptr *val) { }
297
298// problem is result type, not accumulator type, so outconverter can break this
299#pragma rs reduce(redPtrOutBreak) accumulator(AccumInt) outconverter(OutPtrBreak)
300static void OutPtrBreak(Ptr *out, const int *val) { }
301
302/////////////////////////////////////////////////////////////////////////
303
304typedef Ptr PtrArray7[7];
305
306// cannot export array of pointer
307#pragma rs reduce(redPtrArray7) accumulator(AccumPtrArray7) combiner(CombPtrArray7)
308static void AccumPtrArray7(PtrArray7 *accum, int val) { }
309static void CombPtrArray7(PtrArray7 *accum, const PtrArray7 *other) { }
310
311// problem is result type, not accumulator type, so outconverter can fix this
312#pragma rs reduce(redPtrArray7OutFix) accumulator(AccumPtrArray7) combiner(CombPtrArray7) \
313  outconverter(OutPtrArray7Fix)
314static void OutPtrArray7Fix(int *out, const PtrArray7 *val) { }
315
316// problem is result type, not accumulator type, so outconverter can break this
317#pragma rs reduce(redPtrArray7OutBreak) accumulator(AccumInt) outconverter(OutPtrArray7Break)
318static void OutPtrArray7Break(PtrArray7 *out, const int *val) { }
319
320/////////////////////////////////////////////////////////////////////////
321
322struct StructPtr1 {
323  Ptr p;
324  double d;
325};
326
327struct StructPtr11 {
328  Ptr p;
329  double d;
330  int i;
331};
332
333struct StructPtr111 {
334  Ptr p;
335  double d;
336  int i;
337  float f;
338};
339
340// cannot export struct containing pointer
341#pragma rs reduce(redStructPtr) accumulator(AccumStructPtr) combiner(CombStructPtr)
342static void AccumStructPtr(struct StructPtr1 *accum, int val) { }
343static void CombStructPtr(struct StructPtr1 *accum, const struct StructPtr1 *other) { }
344
345// problem is result type, not accumulator type, so outconverter can fix this
346#pragma rs reduce(redStructPtrOutFix) accumulator(AccumStructPtrOutFix) \
347  combiner(CombStructPtrOutFix) outconverter(OutStructPtrFix)
348static void AccumStructPtrOutFix(struct StructPtr11 *accum, int val) { }
349static void CombStructPtrOutFix(struct StructPtr11 *accum, const struct StructPtr11 *other) { }
350static void OutStructPtrFix(int *out, const struct StructPtr11 *val) { }
351
352// problem is result type, not accumulator type, so outconverter can break this
353#pragma rs reduce(redStructPtrOutBreak) accumulator(AccumInt) outconverter(OutStructPtrBreak)
354static void OutStructPtrBreak(struct StructPtr111 *out, const int *val) { }
355
356/////////////////////////////////////////////////////////////////////////
357
358struct StructPtr2 {
359  float f;
360  Ptr p;
361};
362typedef struct StructPtr2 StructPtr2Array[7];
363
364struct StructPtr22 {
365  float f;
366  Ptr p;
367  char c;
368};
369typedef struct StructPtr22 StructPtr22Array[7];
370
371struct StructPtr222 {
372  float f;
373  Ptr p;
374  char c;
375  double d;
376};
377typedef struct StructPtr222 StructPtr222Array[7];
378
379// cannot export struct containing pointer
380#pragma rs reduce(redStructPtrArray) accumulator(AccumStructPtrArray) combiner(CombStructPtrArray)
381static void AccumStructPtrArray(StructPtr2Array *accum, int val) { }
382static void CombStructPtrArray(StructPtr2Array *accum, const StructPtr2Array *other) { }
383
384// problem is result type, not accumulator type, so outconverter can fix this
385#pragma rs reduce(redStructPtrArrayOutFix) accumulator(AccumStructPtrArrayOutFix) \
386  combiner(CombStructPtrArrayOutFix) outconverter(OutStructPtrArrayFix)
387static void AccumStructPtrArrayOutFix(StructPtr22Array *accum, int val) { }
388static void CombStructPtrArrayOutFix(StructPtr22Array *accum, const StructPtr22Array *other) { }
389static void OutStructPtrArrayFix(int *out, const StructPtr22Array *val) { }
390
391// problem is result type, not accumulator type, so outconverter can break this
392#pragma rs reduce(redStructPtrArrayOutBreak) accumulator(AccumInt) \
393  outconverter(OutStructPtrArrayBreak)
394static void OutStructPtrArrayBreak(StructPtr22Array *out, const int *val) { }
395
396/////////////////////////////////////////////////////////////////////////
397
398typedef void Fn(void);
399
400// cannot export function type
401//
402// NOTE: Not suitable as accumulator data type, regardless of whether
403//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
404#pragma rs reduce(redFn) accumulator(AccumInt) outconverter(OutFn)
405static void OutFn(Fn *out, const int *val) { }
406
407/////////////////////////////////////////////////////////////////////////
408
409struct Incomplete;
410
411// result type cannot be incomplete type
412//
413// NOTE: Not suitable as accumulator data type, regardless of whether
414//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
415#pragma rs reduce(redStructIncomplete) accumulator(AccumInt) outconverter(OutStructIncomplete)
416static void OutStructIncomplete(struct Incomplete *out, const int *val) { }
417
418/////////////////////////////////////////////////////////////////////////
419
420typedef int IntA[]; // incomplete (unknown element count)
421
422// result type cannot be incomplete type
423//
424// NOTE: Not suitable as accumulator data type, regardless of whether
425//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
426#pragma rs reduce(redArrayIncomplete) accumulator(AccumInt) outconverter(OutArrayIncomplete)
427static void OutArrayIncomplete(IntA *out, const int *val) { }
428