Debian Codegraph @

third_party/spirv-cross/reference/shaders-msl/comp/copy-array-of-arrays.force-native-array.comp

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 BUF
9 {
10 int a;
11 float b;
12 float c;
13 };
14
15 constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u);
16
17 constant float _16[2] = { 1.0, 2.0 };
18 constant float _19[2] = { 3.0, 4.0 };
19 constant float _20[2][2] = { { 1.0, 2.0 }, { 3.0, 4.0 } };
20 constant float _21[2][2][2] = { { { 1.0, 2.0 }, { 3.0, 4.0 } }, { { 1.0, 2.0 }, { 3.0, 4.0 } } };
21
22 template<typename T, uint A>
23 inline void spvArrayCopyFromConstantToStack1(thread T (&dst)[A], constant T (&src)[A])
24 {
25 for (uint i = 0; i < A; i++)
26 {
27 dst[i] = src[i];
28 }
29 }
30
31 template<typename T, uint A>
32 inline void spvArrayCopyFromConstantToThreadGroup1(threadgroup T (&dst)[A], constant T (&src)[A])
33 {
34 for (uint i = 0; i < A; i++)
35 {
36 dst[i] = src[i];
37 }
38 }
39
40 template<typename T, uint A>
41 inline void spvArrayCopyFromStackToStack1(thread T (&dst)[A], thread const T (&src)[A])
42 {
43 for (uint i = 0; i < A; i++)
44 {
45 dst[i] = src[i];
46 }
47 }
48
49 template<typename T, uint A>
50 inline void spvArrayCopyFromStackToThreadGroup1(threadgroup T (&dst)[A], thread const T (&src)[A])
51 {
52 for (uint i = 0; i < A; i++)
53 {
54 dst[i] = src[i];
55 }
56 }
57
58 template<typename T, uint A>
59 inline void spvArrayCopyFromThreadGroupToStack1(thread T (&dst)[A], threadgroup const T (&src)[A])
60 {
61 for (uint i = 0; i < A; i++)
62 {
63 dst[i] = src[i];
64 }
65 }
66
67 template<typename T, uint A>
68 inline void spvArrayCopyFromThreadGroupToThreadGroup1(threadgroup T (&dst)[A], threadgroup const T (&src)[A])
69 {
70 for (uint i = 0; i < A; i++)
71 {
72 dst[i] = src[i];
73 }
74 }
75
76 template<typename T, uint A>
77 inline void spvArrayCopyFromDeviceToDevice1(device T (&dst)[A], device const T (&src)[A])
78 {
79 for (uint i = 0; i < A; i++)
80 {
81 dst[i] = src[i];
82 }
83 }
84
85 template<typename T, uint A>
86 inline void spvArrayCopyFromConstantToDevice1(device T (&dst)[A], constant T (&src)[A])
87 {
88 for (uint i = 0; i < A; i++)
89 {
90 dst[i] = src[i];
91 }
92 }
93
94 template<typename T, uint A>
95 inline void spvArrayCopyFromStackToDevice1(device T (&dst)[A], thread const T (&src)[A])
96 {
97 for (uint i = 0; i < A; i++)
98 {
99 dst[i] = src[i];
100 }
101 }
102
103 template<typename T, uint A>
104 inline void spvArrayCopyFromThreadGroupToDevice1(device T (&dst)[A], threadgroup const T (&src)[A])
105 {
106 for (uint i = 0; i < A; i++)
107 {
108 dst[i] = src[i];
109 }
110 }
111
112 template<typename T, uint A>
113 inline void spvArrayCopyFromDeviceToStack1(thread T (&dst)[A], device const T (&src)[A])
114 {
115 for (uint i = 0; i < A; i++)
116 {
117 dst[i] = src[i];
118 }
119 }
120
121 template<typename T, uint A>
122 inline void spvArrayCopyFromDeviceToThreadGroup1(threadgroup T (&dst)[A], device const T (&src)[A])
123 {
124 for (uint i = 0; i < A; i++)
125 {
126 dst[i] = src[i];
127 }
128 }
129
130 template<typename T, uint A, uint B>
131 inline void spvArrayCopyFromConstantToStack2(thread T (&dst)[A][B], constant T (&src)[A][B])
132 {
133 for (uint i = 0; i < A; i++)
134 {
135 spvArrayCopyFromConstantToStack1(dst[i], src[i]);
136 }
137 }
138
139 template<typename T, uint A, uint B>
140 inline void spvArrayCopyFromConstantToThreadGroup2(threadgroup T (&dst)[A][B], constant T (&src)[A][B])
141 {
142 for (uint i = 0; i < A; i++)
143 {
144 spvArrayCopyFromConstantToThreadGroup1(dst[i], src[i]);
145 }
146 }
147
148 template<typename T, uint A, uint B>
149 inline void spvArrayCopyFromStackToStack2(thread T (&dst)[A][B], thread const T (&src)[A][B])
150 {
151 for (uint i = 0; i < A; i++)
152 {
153 spvArrayCopyFromStackToStack1(dst[i], src[i]);
154 }
155 }
156
157 template<typename T, uint A, uint B>
158 inline void spvArrayCopyFromStackToThreadGroup2(threadgroup T (&dst)[A][B], thread const T (&src)[A][B])
159 {
160 for (uint i = 0; i < A; i++)
161 {
162 spvArrayCopyFromStackToThreadGroup1(dst[i], src[i]);
163 }
164 }
165
166 template<typename T, uint A, uint B>
167 inline void spvArrayCopyFromThreadGroupToStack2(thread T (&dst)[A][B], threadgroup const T (&src)[A][B])
168 {
169 for (uint i = 0; i < A; i++)
170 {
171 spvArrayCopyFromThreadGroupToStack1(dst[i], src[i]);
172 }
173 }
174
175 template<typename T, uint A, uint B>
176 inline void spvArrayCopyFromThreadGroupToThreadGroup2(threadgroup T (&dst)[A][B], threadgroup const T (&src)[A][B])
177 {
178 for (uint i = 0; i < A; i++)
179 {
180 spvArrayCopyFromThreadGroupToThreadGroup1(dst[i], src[i]);
181 }
182 }
183
184 template<typename T, uint A, uint B>
185 inline void spvArrayCopyFromDeviceToDevice2(device T (&dst)[A][B], device const T (&src)[A][B])
186 {
187 for (uint i = 0; i < A; i++)
188 {
189 spvArrayCopyFromDeviceToDevice1(dst[i], src[i]);
190 }
191 }
192
193 template<typename T, uint A, uint B>
194 inline void spvArrayCopyFromConstantToDevice2(device T (&dst)[A][B], constant T (&src)[A][B])
195 {
196 for (uint i = 0; i < A; i++)
197 {
198 spvArrayCopyFromConstantToDevice1(dst[i], src[i]);
199 }
200 }
201
202 template<typename T, uint A, uint B>
203 inline void spvArrayCopyFromStackToDevice2(device T (&dst)[A][B], thread const T (&src)[A][B])
204 {
205 for (uint i = 0; i < A; i++)
206 {
207 spvArrayCopyFromStackToDevice1(dst[i], src[i]);
208 }
209 }
210
211 template<typename T, uint A, uint B>
212 inline void spvArrayCopyFromThreadGroupToDevice2(device T (&dst)[A][B], threadgroup const T (&src)[A][B])
213 {
214 for (uint i = 0; i < A; i++)
215 {
216 spvArrayCopyFromThreadGroupToDevice1(dst[i], src[i]);
217 }
218 }
219
220 template<typename T, uint A, uint B>
221 inline void spvArrayCopyFromDeviceToStack2(thread T (&dst)[A][B], device const T (&src)[A][B])
222 {
223 for (uint i = 0; i < A; i++)
224 {
225 spvArrayCopyFromDeviceToStack1(dst[i], src[i]);
226 }
227 }
228
229 template<typename T, uint A, uint B>
230 inline void spvArrayCopyFromDeviceToThreadGroup2(threadgroup T (&dst)[A][B], device const T (&src)[A][B])
231 {
232 for (uint i = 0; i < A; i++)
233 {
234 spvArrayCopyFromDeviceToThreadGroup1(dst[i], src[i]);
235 }
236 }
237
238 template<typename T, uint A, uint B, uint C>
239 inline void spvArrayCopyFromConstantToStack3(thread T (&dst)[A][B][C], constant T (&src)[A][B][C])
240 {
241 for (uint i = 0; i < A; i++)
242 {
243 spvArrayCopyFromConstantToStack2(dst[i], src[i]);
244 }
245 }
246
247 template<typename T, uint A, uint B, uint C>
248 inline void spvArrayCopyFromConstantToThreadGroup3(threadgroup T (&dst)[A][B][C], constant T (&src)[A][B][C])
249 {
250 for (uint i = 0; i < A; i++)
251 {
252 spvArrayCopyFromConstantToThreadGroup2(dst[i], src[i]);
253 }
254 }
255
256 template<typename T, uint A, uint B, uint C>
257 inline void spvArrayCopyFromStackToStack3(thread T (&dst)[A][B][C], thread const T (&src)[A][B][C])
258 {
259 for (uint i = 0; i < A; i++)
260 {
261 spvArrayCopyFromStackToStack2(dst[i], src[i]);
262 }
263 }
264
265 template<typename T, uint A, uint B, uint C>
266 inline void spvArrayCopyFromStackToThreadGroup3(threadgroup T (&dst)[A][B][C], thread const T (&src)[A][B][C])
267 {
268 for (uint i = 0; i < A; i++)
269 {
270 spvArrayCopyFromStackToThreadGroup2(dst[i], src[i]);
271 }
272 }
273
274 template<typename T, uint A, uint B, uint C>
275 inline void spvArrayCopyFromThreadGroupToStack3(thread T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C])
276 {
277 for (uint i = 0; i < A; i++)
278 {
279 spvArrayCopyFromThreadGroupToStack2(dst[i], src[i]);
280 }
281 }
282
283 template<typename T, uint A, uint B, uint C>
284 inline void spvArrayCopyFromThreadGroupToThreadGroup3(threadgroup T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C])
285 {
286 for (uint i = 0; i < A; i++)
287 {
288 spvArrayCopyFromThreadGroupToThreadGroup2(dst[i], src[i]);
289 }
290 }
291
292 template<typename T, uint A, uint B, uint C>
293 inline void spvArrayCopyFromDeviceToDevice3(device T (&dst)[A][B][C], device const T (&src)[A][B][C])
294 {
295 for (uint i = 0; i < A; i++)
296 {
297 spvArrayCopyFromDeviceToDevice2(dst[i], src[i]);
298 }
299 }
300
301 template<typename T, uint A, uint B, uint C>
302 inline void spvArrayCopyFromConstantToDevice3(device T (&dst)[A][B][C], constant T (&src)[A][B][C])
303 {
304 for (uint i = 0; i < A; i++)
305 {
306 spvArrayCopyFromConstantToDevice2(dst[i], src[i]);
307 }
308 }
309
310 template<typename T, uint A, uint B, uint C>
311 inline void spvArrayCopyFromStackToDevice3(device T (&dst)[A][B][C], thread const T (&src)[A][B][C])
312 {
313 for (uint i = 0; i < A; i++)
314 {
315 spvArrayCopyFromStackToDevice2(dst[i], src[i]);
316 }
317 }
318
319 template<typename T, uint A, uint B, uint C>
320 inline void spvArrayCopyFromThreadGroupToDevice3(device T (&dst)[A][B][C], threadgroup const T (&src)[A][B][C])
321 {
322 for (uint i = 0; i < A; i++)
323 {
324 spvArrayCopyFromThreadGroupToDevice2(dst[i], src[i]);
325 }
326 }
327
328 template<typename T, uint A, uint B, uint C>
329 inline void spvArrayCopyFromDeviceToStack3(thread T (&dst)[A][B][C], device const T (&src)[A][B][C])
330 {
331 for (uint i = 0; i < A; i++)
332 {
333 spvArrayCopyFromDeviceToStack2(dst[i], src[i]);
334 }
335 }
336
337 template<typename T, uint A, uint B, uint C>
338 inline void spvArrayCopyFromDeviceToThreadGroup3(threadgroup T (&dst)[A][B][C], device const T (&src)[A][B][C])
339 {
340 for (uint i = 0; i < A; i++)
341 {
342 spvArrayCopyFromDeviceToThreadGroup2(dst[i], src[i]);
343 }
344 }
345
346 kernel void main0(device BUF& o [[buffer(0)]])
347 {
348 float c[2][2][2];
349 spvArrayCopyFromConstantToStack3(c, _21);
350 o.a = int(c[1][1][1]);
351 float _43[2] = { o.b, o.c };
352 float _48[2] = { o.b, o.b };
353 float _49[2][2] = { { _43[0], _43[1] }, { _48[0], _48[1] } };
354 float _54[2] = { o.c, o.c };
355 float _59[2] = { o.c, o.b };
356 float _60[2][2] = { { _54[0], _54[1] }, { _59[0], _59[1] } };
357 float _61[2][2][2] = { { { _49[0][0], _49[0][1] }, { _49[1][0], _49[1][1] } }, { { _60[0][0], _60[0][1] }, { _60[1][0], _60[1][1] } } };
358 float d[2][2][2];
359 spvArrayCopyFromStackToStack3(d, _61);
360 float e[2][2][2];
361 spvArrayCopyFromStackToStack3(e, d);
362 o.b = e[1][0][1];
363 }
364