11623659165bb24d733a40124e929cfd42aa917e3David Gross// -Wall 265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma version(1) 365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs java_package_name(export) 465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// trivial accumulator for use multiple times later 665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumInt(int *accum, int val) { } 765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// NOTE: union and bitfield errors are only emitted once per type, so 965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// we have multiple types here to ensure that we issue errors 1065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// in multiple contexts. 1165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 1265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// NOTE: accumulator data type is restricted in certain ways regardless 1365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// of result type; we do not test that here. This is covered 1465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// in the test case reduce_general_bad_accumulator.rs. 1565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 1665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 1765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 1865f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef unsigned int UIntA916[9][16]; 1965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 2065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be multidimensional array 2165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUInt2dA) accumulator(AccumUInt2dA) combiner(CombUInt2dA) 2265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumUInt2dA(UIntA916 *accum, int val) { } 2365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombUInt2dA(UIntA916 *accum, const UIntA916 *val) { } 2465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 2565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 2665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUInt2dAOutFix) accumulator(AccumUInt2dA) combiner(CombUInt2dA) \ 2765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutUInt2dAFix) 2865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUInt2dAFix(uint *out, const UIntA916 *val) { } 2965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 3065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 3165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUInt2dAOutBreak) accumulator(AccumInt) outconverter(OutUInt2dABreak) 3265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUInt2dABreak(UIntA916 *out, const int *val) { } 3365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 3465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 3565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 3665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionShortDouble { 3765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross short s; 3865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 3965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 4065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 4165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionCharInt { 4265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross char c; 4365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int i; 4465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 4565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 4665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionLongFloat { 4765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross long l; 4865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 4965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 5065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 5165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be union 5265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionShortDouble) accumulator(AccumUnionShortDouble) \ 5365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombineUnionShortDouble) 5465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumUnionShortDouble(union UnionShortDouble *accum, short s, double d) { } 5565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineUnionShortDouble(union UnionShortDouble *accum, 5665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross const union UnionShortDouble *other) { } 5765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 5865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 5965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionCharIntOutFix) accumulator(AccumUnionCharInt) \ 6065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombineUnionCharInt) outconverter(OutUnionCharIntFix) 6165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumUnionCharInt(union UnionCharInt *accum, short s, double d) { } 6265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineUnionCharInt(union UnionCharInt *accum, const union UnionCharInt *other) { } 6365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUnionCharIntFix(int *out, const union UnionCharInt *val) { } 6465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 6565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 6665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionLongFloatOutBreak) accumulator(AccumInt) \ 6765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutUnionLongFloatBreak) 6865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUnionLongFloatBreak(union UnionLongFloat *out, const int *val) { } 6965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 7065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 7165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 7265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionIntFloat { 7365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross short s; 7465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 7565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 7665f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef union UnionIntFloat UnionIntFloatArray[10]; 7765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 7865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionDoubleFloat { 7965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 8065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 8165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 8265f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef union UnionDoubleFloat UnionDoubleFloatArray[10]; 8365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 8465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossunion UnionCharLong { 8565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross char c; 8665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross long l; 8765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 8865f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef union UnionCharLong UnionCharLongArray[10]; 8965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 9065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export array of union 9165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionIntFloatArray) accumulator(AccumUnionIntFloatArray) \ 9265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombineUnionIntFloatArray) 9365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumUnionIntFloatArray(UnionIntFloatArray *accum, int val) { } 9465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineUnionIntFloatArray(UnionIntFloatArray *accum, 9565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross const UnionIntFloatArray *other) { } 9665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 9765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 9865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionDoubleFloatArrayOutFix) accumulator(AccumUnionDoubleFloatArray) \ 9965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombineUnionDoubleFloatArray) outconverter(OutUnionDoubleFloatArrayFix) 10065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumUnionDoubleFloatArray(UnionDoubleFloatArray *accum, short s, double d) { } 10165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineUnionDoubleFloatArray(UnionDoubleFloatArray *accum, 10265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross const UnionDoubleFloatArray *other) { } 10365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUnionDoubleFloatArrayFix(int *out, const UnionDoubleFloatArray *val) { } 10465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 10565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 10665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redUnionCharLongArrayOutBreak) accumulator(AccumInt) \ 10765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutUnionCharLongArrayBreak) 10865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutUnionCharLongArrayBreak(UnionCharLongArray *out, const int *val) { } 10965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 11065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 11165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 11265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits1 { 11365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int b:1; 11465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 11565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 11665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits11 { 11765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int c:1; 11865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int d:1; 11965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 12065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 12165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits111 { 12265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int e:1; 12365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int f:1; 12465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int g:1; 12565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 12665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 12765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export struct with bitfield 12865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBits) accumulator(AccumBits) combiner(CombineBits) 12965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumBits(struct Bits1 *accum, int val) { } 13065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineBits(struct Bits1 *accum, const struct Bits1 *other) { } 13165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 13265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 13365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBitsOutFix) accumulator(AccumBitsOutFix) combiner(CombineBitsOutFix) \ 13465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutBitsFix) 13565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumBitsOutFix(struct Bits11 *accum, int val) { } 13665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineBitsOutFix(struct Bits11 *accum, const struct Bits11 *other) { } 13765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutBitsFix(int *out, const struct Bits11 *val) { } 13865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 13965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 14065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBitsOutBreak) accumulator(AccumInt) outconverter(OutBitsBreak) 14165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutBitsBreak(struct Bits111 *out, const int *val) { } 14265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 14365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 14465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 14565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits2 { 14665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int b:2; 14765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 14865f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct Bits2 Bits2Array[10]; 14965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 15065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits22 { 15165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int c:2; 15265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int d:2; 15365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 15465f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct Bits22 Bits22Array[10]; 15565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 15665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Bits222 { 15765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int e:2; 15865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int f:2; 15965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int g:2; 16065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 16165f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct Bits222 Bits222Array[10]; 16265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 16365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export array of struct with bitfield 16465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBitsArray) accumulator(AccumBitsArray) combiner(CombineBitsArray) 16565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumBitsArray(Bits2Array *accum, int val) { } 16665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineBitsArray(Bits2Array *accum, const Bits2Array *other) { } 16765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 16865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 16965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBitsArrayOutFix) accumulator(AccumBitsArrayOutFix) \ 17065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombineBitsArrayOutFix) outconverter(OutBitsArrayFix) 17165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumBitsArrayOutFix(Bits22Array *accum, int val) { } 17265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineBitsArrayOutFix(Bits22Array *accum, const Bits22Array *other) { } 17365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutBitsArrayFix(int *out, const Bits22Array *val) { } 17465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 17565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 17665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redBitsArrayOutBreak) accumulator(AccumInt) outconverter(OutBitsArrayBreak) 17765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutBitsArrayBreak(Bits222Array *out, const int *val) { } 17865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 17965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 18065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 18165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be matrix 18265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMat) accumulator(AccumMat) 18365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumMat(rs_matrix2x2 *accum, rs_matrix2x2 val) { } 18465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 18565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 18665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMatOutFix) accumulator(AccumMat) outconverter(OutMatFix) 18765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutMatFix(int *out, const rs_matrix2x2 *val) { } 18865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 18965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 19065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMatOutBreak) accumulator(AccumInt) outconverter(OutMatBreak) 19165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutMatBreak(rs_matrix2x2 *out, const int *val) { } 19265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 19365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 19465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 19565f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef rs_matrix2x2 ArrayMatrix2x2[10]; 19665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 19765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be array of matrix 19865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMatArray) accumulator(AccumMatArray) combiner(CombineMatArray) 19965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumMatArray(ArrayMatrix2x2 *accum, rs_matrix2x2 val) { } 20065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombineMatArray(ArrayMatrix2x2 *accum, const ArrayMatrix2x2 *other) { } 20165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 20265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 20365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMatArrayOutFix) accumulator(AccumMatArray) combiner(CombineMatArray) \ 20465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutMatArrayFix) 20565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutMatArrayFix(int *out, const ArrayMatrix2x2 *val) { } 20665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 20765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 20865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redMatArrayOutBreak) accumulator(AccumInt) outconverter(OutMatArrayBreak) 20965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutMatArrayBreak(ArrayMatrix2x2 *out, const int *val) { } 21065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 21165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 21265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 21365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be object type 21465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redAlloc) accumulator(AccumInt) outconverter(OutAlloc) 21565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutAlloc(rs_allocation *out, const int *val) { } 21665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 21765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 21865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 21965f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef rs_allocation AllocArray[10]; 22065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 22165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be array of object type 22265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redAllocArray) accumulator(AccumAllocArray) outconverter(OutAllocArray) 22365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumAllocArray(int *accum, int val) { } 22465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutAllocArray(AllocArray *out, const int *val) { } 22565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 22665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 22765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 22865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructObj1 { 22965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int f; 23065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross rs_element e; 23165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 23265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 23365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be struct containing object type 23465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructObj) accumulator(AccumStructObj) outconverter(OutStructObj) 23565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructObj(int *accum, int val) { } 23665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructObj(struct StructObj1 *out, const int *val) { } 23765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 23865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 23965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 24065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructObj2 { 24165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross rs_type t; 24265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 24365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 24465f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct StructObj2 StructObj2Array[10]; 24565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 24665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be array of struct containing object type 24765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructObjArray) accumulator(AccumStructObjArray) \ 24865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutStructObjArray) 24965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructObjArray(int *accum, int val) { } 25065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructObjArray(StructObj2Array *out, const int *val) { } 25165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 25265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 25365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 25465f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef char *Ptr; 25565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 25665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be pointer 25765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtr) accumulator(AccumPtr) combiner(CombPtr) 25865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumPtr(Ptr *accum, char val) { } 25965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombPtr(Ptr *accum, const Ptr *other) { } 26065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 26165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 26265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtrOutFix) accumulator(AccumPtr) combiner(CombPtr) \ 26365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutPtrFix) 26465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutPtrFix(int *out, const Ptr *val) { } 26565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 26665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 26765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtrOutBreak) accumulator(AccumInt) outconverter(OutPtrBreak) 26865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutPtrBreak(Ptr *out, const int *val) { } 26965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 27065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 27165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 27265f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef Ptr PtrArray7[7]; 27365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 27465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export array of pointer 27565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtrArray7) accumulator(AccumPtrArray7) combiner(CombPtrArray7) 27665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumPtrArray7(PtrArray7 *accum, int val) { } 27765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombPtrArray7(PtrArray7 *accum, const PtrArray7 *other) { } 27865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 27965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 28065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtrArray7OutFix) accumulator(AccumPtrArray7) combiner(CombPtrArray7) \ 28165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutPtrArray7Fix) 28265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutPtrArray7Fix(int *out, const PtrArray7 *val) { } 28365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 28465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 28565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redPtrArray7OutBreak) accumulator(AccumInt) outconverter(OutPtrArray7Break) 28665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutPtrArray7Break(PtrArray7 *out, const int *val) { } 28765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 28865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 28965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 29065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr1 { 29165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 29265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 29365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 29465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 29565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr11 { 29665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 29765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 29865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int i; 29965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 30065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 30165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr111 { 30265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 30365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 30465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross int i; 30565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 30665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 30765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 30865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export struct containing pointer 30965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtr) accumulator(AccumStructPtr) combiner(CombStructPtr) 31065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructPtr(struct StructPtr1 *accum, int val) { } 31165f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombStructPtr(struct StructPtr1 *accum, const struct StructPtr1 *other) { } 31265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 31365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 31465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtrOutFix) accumulator(AccumStructPtrOutFix) \ 31565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombStructPtrOutFix) outconverter(OutStructPtrFix) 31665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructPtrOutFix(struct StructPtr11 *accum, int val) { } 31765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombStructPtrOutFix(struct StructPtr11 *accum, const struct StructPtr11 *other) { } 31865f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructPtrFix(int *out, const struct StructPtr11 *val) { } 31965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 32065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 32165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtrOutBreak) accumulator(AccumInt) outconverter(OutStructPtrBreak) 32265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructPtrBreak(struct StructPtr111 *out, const int *val) { } 32365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 32465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 32565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 32665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr2 { 32765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 32865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 32965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 33065f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct StructPtr2 StructPtr2Array[7]; 33165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 33265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr22 { 33365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 33465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 33565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross char c; 33665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 33765f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct StructPtr22 StructPtr22Array[7]; 33865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 33965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct StructPtr222 { 34065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross float f; 34165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross Ptr p; 34265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross char c; 34365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross double d; 34465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross}; 34565f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef struct StructPtr222 StructPtr222Array[7]; 34665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 34765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export struct containing pointer 34865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtrArray) accumulator(AccumStructPtrArray) combiner(CombStructPtrArray) 34965f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructPtrArray(StructPtr2Array *accum, int val) { } 35065f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombStructPtrArray(StructPtr2Array *accum, const StructPtr2Array *other) { } 35165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 35265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can fix this 35365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtrArrayOutFix) accumulator(AccumStructPtrArrayOutFix) \ 35465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross combiner(CombStructPtrArrayOutFix) outconverter(OutStructPtrArrayFix) 35565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void AccumStructPtrArrayOutFix(StructPtr22Array *accum, int val) { } 35665f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void CombStructPtrArrayOutFix(StructPtr22Array *accum, const StructPtr22Array *other) { } 35765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructPtrArrayFix(int *out, const StructPtr22Array *val) { } 35865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 35965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// problem is result type, not accumulator type, so outconverter can break this 36065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructPtrArrayOutBreak) accumulator(AccumInt) \ 36165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross outconverter(OutStructPtrArrayBreak) 36265f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructPtrArrayBreak(StructPtr22Array *out, const int *val) { } 36365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 36465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 36565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 36665f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef void Fn(void); 36765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 36865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// cannot export function type 36965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// 37065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// NOTE: Not suitable as accumulator data type, regardless of whether 37165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// we have outconverter; that's tested in reduce_general_bad_accumulator.rs. 37265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redFn) accumulator(AccumInt) outconverter(OutFn) 37365f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutFn(Fn *out, const int *val) { } 37465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 37565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 37665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 37765f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstruct Incomplete; 37865f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 37965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be incomplete type 38065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// 38165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// NOTE: Not suitable as accumulator data type, regardless of whether 38265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// we have outconverter; that's tested in reduce_general_bad_accumulator.rs. 38365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redStructIncomplete) accumulator(AccumInt) outconverter(OutStructIncomplete) 38465f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutStructIncomplete(struct Incomplete *out, const int *val) { } 38565f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 38665f23ed862e1a1e16477ba740f295ff4a83ac822David Gross///////////////////////////////////////////////////////////////////////// 38765f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 38865f23ed862e1a1e16477ba740f295ff4a83ac822David Grosstypedef int IntA[]; // incomplete (unknown element count) 38965f23ed862e1a1e16477ba740f295ff4a83ac822David Gross 39065f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// result type cannot be incomplete type 39165f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// 39265f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// NOTE: Not suitable as accumulator data type, regardless of whether 39365f23ed862e1a1e16477ba740f295ff4a83ac822David Gross// we have outconverter; that's tested in reduce_general_bad_accumulator.rs. 39465f23ed862e1a1e16477ba740f295ff4a83ac822David Gross#pragma rs reduce(redArrayIncomplete) accumulator(AccumInt) outconverter(OutArrayIncomplete) 39565f23ed862e1a1e16477ba740f295ff4a83ac822David Grossstatic void OutArrayIncomplete(IntA *out, const int *val) { } 396