Debian Codegraph @

third_party/spirv-cross/reference/shaders-msl-no-opt/frag/subgroups.nocompat.invalid.vk.msl21.frag

raw
1 #pragma clang diagnostic ignored "-Wmissing-prototypes"
2
3 #include <metal_stdlib>
4 #include <simd/simd.h>
5
6 using namespace metal;
7
8 struct main0_out
9 {
10 float FragColor [[color(0)]];
11 };
12
13 template<typename T>
14 inline T spvSubgroupBroadcast(T value, ushort lane)
15 {
16 return simd_broadcast(value, lane);
17 }
18
19 template<>
20 inline bool spvSubgroupBroadcast(bool value, ushort lane)
21 {
22 return !!simd_broadcast((ushort)value, lane);
23 }
24
25 template<uint N>
26 inline vec<bool, N> spvSubgroupBroadcast(vec<bool, N> value, ushort lane)
27 {
28 return (vec<bool, N>)simd_broadcast((vec<ushort, N>)value, lane);
29 }
30
31 template<typename T>
32 inline T spvSubgroupBroadcastFirst(T value)
33 {
34 return simd_broadcast_first(value);
35 }
36
37 template<>
38 inline bool spvSubgroupBroadcastFirst(bool value)
39 {
40 return !!simd_broadcast_first((ushort)value);
41 }
42
43 template<uint N>
44 inline vec<bool, N> spvSubgroupBroadcastFirst(vec<bool, N> value)
45 {
46 return (vec<bool, N>)simd_broadcast_first((vec<ushort, N>)value);
47 }
48
49 inline uint4 spvSubgroupBallot(bool value)
50 {
51 simd_vote vote = simd_ballot(value);
52 // simd_ballot() returns a 64-bit integer-like object, but
53 // SPIR-V callers expect a uint4. We must convert.
54 // FIXME: This won't include higher bits if Apple ever supports
55 // 128 lanes in an SIMD-group.
56 return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> 32) & 0xFFFFFFFF), 0, 0);
57 }
58
59 inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit)
60 {
61 return !!extract_bits(ballot[bit / 32], bit % 32, 1);
62 }
63
64 inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize)
65 {
66 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
67 ballot &= mask;
68 return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0);
69 }
70
71 inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize)
72 {
73 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
74 ballot &= mask;
75 return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0);
76 }
77
78 inline uint spvPopCount4(uint4 ballot)
79 {
80 return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w);
81 }
82
83 inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize)
84 {
85 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
86 return spvPopCount4(ballot & mask);
87 }
88
89 inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)
90 {
91 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0));
92 return spvPopCount4(ballot & mask);
93 }
94
95 inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)
96 {
97 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));
98 return spvPopCount4(ballot & mask);
99 }
100
101 template<typename T>
102 inline bool spvSubgroupAllEqual(T value)
103 {
104 return simd_all(all(value == simd_broadcast_first(value)));
105 }
106
107 template<>
108 inline bool spvSubgroupAllEqual(bool value)
109 {
110 return simd_all(value) || !simd_any(value);
111 }
112
113 template<uint N>
114 inline bool spvSubgroupAllEqual(vec<bool, N> value)
115 {
116 return simd_all(all(value == (vec<bool, N>)simd_broadcast_first((vec<ushort, N>)value)));
117 }
118
119 template<typename T>
120 inline T spvSubgroupShuffle(T value, ushort lane)
121 {
122 return simd_shuffle(value, lane);
123 }
124
125 template<>
126 inline bool spvSubgroupShuffle(bool value, ushort lane)
127 {
128 return !!simd_shuffle((ushort)value, lane);
129 }
130
131 template<uint N>
132 inline vec<bool, N> spvSubgroupShuffle(vec<bool, N> value, ushort lane)
133 {
134 return (vec<bool, N>)simd_shuffle((vec<ushort, N>)value, lane);
135 }
136
137 template<typename T>
138 inline T spvSubgroupShuffleXor(T value, ushort mask)
139 {
140 return simd_shuffle_xor(value, mask);
141 }
142
143 template<>
144 inline bool spvSubgroupShuffleXor(bool value, ushort mask)
145 {
146 return !!simd_shuffle_xor((ushort)value, mask);
147 }
148
149 template<uint N>
150 inline vec<bool, N> spvSubgroupShuffleXor(vec<bool, N> value, ushort mask)
151 {
152 return (vec<bool, N>)simd_shuffle_xor((vec<ushort, N>)value, mask);
153 }
154
155 template<typename T>
156 inline T spvSubgroupShuffleUp(T value, ushort delta)
157 {
158 return simd_shuffle_up(value, delta);
159 }
160
161 template<>
162 inline bool spvSubgroupShuffleUp(bool value, ushort delta)
163 {
164 return !!simd_shuffle_up((ushort)value, delta);
165 }
166
167 template<uint N>
168 inline vec<bool, N> spvSubgroupShuffleUp(vec<bool, N> value, ushort delta)
169 {
170 return (vec<bool, N>)simd_shuffle_up((vec<ushort, N>)value, delta);
171 }
172
173 template<typename T>
174 inline T spvSubgroupShuffleDown(T value, ushort delta)
175 {
176 return simd_shuffle_down(value, delta);
177 }
178
179 template<>
180 inline bool spvSubgroupShuffleDown(bool value, ushort delta)
181 {
182 return !!simd_shuffle_down((ushort)value, delta);
183 }
184
185 template<uint N>
186 inline vec<bool, N> spvSubgroupShuffleDown(vec<bool, N> value, ushort delta)
187 {
188 return (vec<bool, N>)simd_shuffle_down((vec<ushort, N>)value, delta);
189 }
190
191 template<typename T>
192 inline T spvQuadBroadcast(T value, uint lane)
193 {
194 return quad_broadcast(value, lane);
195 }
196
197 template<>
198 inline bool spvQuadBroadcast(bool value, uint lane)
199 {
200 return !!quad_broadcast((ushort)value, lane);
201 }
202
203 template<uint N>
204 inline vec<bool, N> spvQuadBroadcast(vec<bool, N> value, uint lane)
205 {
206 return (vec<bool, N>)quad_broadcast((vec<ushort, N>)value, lane);
207 }
208
209 template<typename T>
210 inline T spvQuadSwap(T value, uint dir)
211 {
212 return quad_shuffle_xor(value, dir + 1);
213 }
214
215 template<>
216 inline bool spvQuadSwap(bool value, uint dir)
217 {
218 return !!quad_shuffle_xor((ushort)value, dir + 1);
219 }
220
221 template<uint N>
222 inline vec<bool, N> spvQuadSwap(vec<bool, N> value, uint dir)
223 {
224 return (vec<bool, N>)quad_shuffle_xor((vec<ushort, N>)value, dir + 1);
225 }
226
227 fragment main0_out main0()
228 {
229 main0_out out = {};
230 uint gl_SubgroupSize = simd_sum(1);
231 uint gl_SubgroupInvocationID = simd_prefix_exclusive_sum(1);
232 uint4 gl_SubgroupEqMask = gl_SubgroupInvocationID >= 32 ? uint4(0, (1 << (gl_SubgroupInvocationID - 32)), uint2(0)) : uint4(1 << gl_SubgroupInvocationID, uint3(0));
233 uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID, 32u), 0)), uint2(0));
234 uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID + 1, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID + 1, 32u), 0)), uint2(0));
235 uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0));
236 uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));
237 out.FragColor = float(gl_SubgroupSize);
238 out.FragColor = float(gl_SubgroupInvocationID);
239 bool elected = simd_is_first();
240 out.FragColor = float4(gl_SubgroupEqMask).x;
241 out.FragColor = float4(gl_SubgroupGeMask).x;
242 out.FragColor = float4(gl_SubgroupGtMask).x;
243 out.FragColor = float4(gl_SubgroupLeMask).x;
244 out.FragColor = float4(gl_SubgroupLtMask).x;
245 float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u);
246 bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u);
247 float3 first = spvSubgroupBroadcastFirst(float3(20.0));
248 bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false));
249 uint4 ballot_value = spvSubgroupBallot(true);
250 bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID);
251 bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u);
252 uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize);
253 uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID);
254 uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID);
255 uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize);
256 uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize);
257 uint shuffled = spvSubgroupShuffle(10u, 8u);
258 bool shuffled_bool = spvSubgroupShuffle(true, 9u);
259 uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u);
260 bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u);
261 uint shuffled_up = spvSubgroupShuffleUp(20u, 4u);
262 bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u);
263 uint shuffled_down = spvSubgroupShuffleDown(20u, 4u);
264 bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u);
265 bool has_all = simd_all(true);
266 bool has_any = simd_any(true);
267 bool has_equal = spvSubgroupAllEqual(0);
268 has_equal = spvSubgroupAllEqual(true);
269 has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0));
270 has_equal = spvSubgroupAllEqual(bool4(true, true, false, true));
271 float4 added = simd_sum(float4(20.0));
272 int4 iadded = simd_sum(int4(20));
273 float4 multiplied = simd_product(float4(20.0));
274 int4 imultiplied = simd_product(int4(20));
275 float4 lo = simd_min(float4(20.0));
276 float4 hi = simd_max(float4(20.0));
277 int4 slo = simd_min(int4(20));
278 int4 shi = simd_max(int4(20));
279 uint4 ulo = simd_min(uint4(20u));
280 uint4 uhi = simd_max(uint4(20u));
281 uint4 anded = simd_and(ballot_value);
282 uint4 ored = simd_or(ballot_value);
283 uint4 xored = simd_xor(ballot_value);
284 added = simd_prefix_inclusive_sum(added);
285 iadded = simd_prefix_inclusive_sum(iadded);
286 multiplied = simd_prefix_inclusive_product(multiplied);
287 imultiplied = simd_prefix_inclusive_product(imultiplied);
288 added = simd_prefix_exclusive_sum(multiplied);
289 multiplied = simd_prefix_exclusive_product(multiplied);
290 iadded = simd_prefix_exclusive_sum(imultiplied);
291 imultiplied = simd_prefix_exclusive_product(imultiplied);
292 added = quad_sum(added);
293 multiplied = quad_product(multiplied);
294 iadded = quad_sum(iadded);
295 imultiplied = quad_product(imultiplied);
296 lo = quad_min(lo);
297 hi = quad_max(hi);
298 ulo = quad_min(ulo);
299 uhi = quad_max(uhi);
300 slo = quad_min(slo);
301 shi = quad_max(shi);
302 anded = quad_and(anded);
303 ored = quad_or(ored);
304 xored = quad_xor(xored);
305 float4 swap_horiz = spvQuadSwap(float4(20.0), 0u);
306 bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u);
307 float4 swap_vertical = spvQuadSwap(float4(20.0), 1u);
308 bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u);
309 float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u);
310 bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u);
311 float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u);
312 bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u);
313 return out;
314 }
315