summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/shader_recompiler/backend/glasm/emit_glasm_image.cpp221
-rw-r--r--src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp165
-rw-r--r--src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp299
3 files changed, 386 insertions, 299 deletions
diff --git a/src/shader_recompiler/backend/glasm/emit_glasm_image.cpp b/src/shader_recompiler/backend/glasm/emit_glasm_image.cpp
index e69de29bb..a32d01925 100644
--- a/src/shader_recompiler/backend/glasm/emit_glasm_image.cpp
+++ b/src/shader_recompiler/backend/glasm/emit_glasm_image.cpp
@@ -0,0 +1,221 @@
1// Copyright 2021 yuzu Emulator Project
2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included.
4
5#include "shader_recompiler/backend/glasm/emit_context.h"
6#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
7#include "shader_recompiler/frontend/ir/modifiers.h"
8#include "shader_recompiler/frontend/ir/value.h"
9
10namespace Shader::Backend::GLASM {
11
12void EmitBindlessImageSampleImplicitLod(EmitContext&) {
13 throw LogicError("Unreachable instruction");
14}
15
16void EmitBindlessImageSampleExplicitLod(EmitContext&) {
17 throw LogicError("Unreachable instruction");
18}
19
20void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
21 throw LogicError("Unreachable instruction");
22}
23
24void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
25 throw LogicError("Unreachable instruction");
26}
27
28void EmitBindlessImageGather(EmitContext&) {
29 throw LogicError("Unreachable instruction");
30}
31
32void EmitBindlessImageGatherDref(EmitContext&) {
33 throw LogicError("Unreachable instruction");
34}
35
36void EmitBindlessImageFetch(EmitContext&) {
37 throw LogicError("Unreachable instruction");
38}
39
40void EmitBindlessImageQueryDimensions(EmitContext&) {
41 throw LogicError("Unreachable instruction");
42}
43
44void EmitBindlessImageQueryLod(EmitContext&) {
45 throw LogicError("Unreachable instruction");
46}
47
48void EmitBindlessImageGradient(EmitContext&) {
49 throw LogicError("Unreachable instruction");
50}
51
52void EmitBindlessImageRead(EmitContext&) {
53 throw LogicError("Unreachable instruction");
54}
55
56void EmitBindlessImageWrite(EmitContext&) {
57 throw LogicError("Unreachable instruction");
58}
59
60void EmitBoundImageSampleImplicitLod(EmitContext&) {
61 throw LogicError("Unreachable instruction");
62}
63
64void EmitBoundImageSampleExplicitLod(EmitContext&) {
65 throw LogicError("Unreachable instruction");
66}
67
68void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
69 throw LogicError("Unreachable instruction");
70}
71
72void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
73 throw LogicError("Unreachable instruction");
74}
75
76void EmitBoundImageGather(EmitContext&) {
77 throw LogicError("Unreachable instruction");
78}
79
80void EmitBoundImageGatherDref(EmitContext&) {
81 throw LogicError("Unreachable instruction");
82}
83
84void EmitBoundImageFetch(EmitContext&) {
85 throw LogicError("Unreachable instruction");
86}
87
88void EmitBoundImageQueryDimensions(EmitContext&) {
89 throw LogicError("Unreachable instruction");
90}
91
92void EmitBoundImageQueryLod(EmitContext&) {
93 throw LogicError("Unreachable instruction");
94}
95
96void EmitBoundImageGradient(EmitContext&) {
97 throw LogicError("Unreachable instruction");
98}
99
100void EmitBoundImageRead(EmitContext&) {
101 throw LogicError("Unreachable instruction");
102}
103
104void EmitBoundImageWrite(EmitContext&) {
105 throw LogicError("Unreachable instruction");
106}
107
108std::string Texture([[maybe_unused]] EmitContext& ctx, IR::TextureInstInfo info,
109 [[maybe_unused]] const IR::Value& index) {
110 // FIXME
111 return fmt::format("texture[{}]", info.descriptor_index);
112}
113
114void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
115 Register coords, Register bias_lc,
116 [[maybe_unused]] const IR::Value& offset) {
117 const auto info{inst.Flags<IR::TextureInstInfo>()};
118 const auto sparse_inst{inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp)};
119 const std::string_view op{info.has_bias ? "TXB" : "TEX"};
120 const std::string_view lod_clamp{info.has_lod_clamp ? ".LODCLAMP" : ""};
121 const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
122 const std::string texture{Texture(ctx, info, index)};
123 const Register ret{ctx.reg_alloc.Define(inst)};
124 // FIXME
125 const bool separate{info.type == TextureType::ColorArrayCube};
126 if (separate) {
127 ctx.Add("{}.F{}{} {},{},{},{},2D;", op, lod_clamp, sparse_mod, ret, coords, bias_lc,
128 texture);
129 } else {
130 ctx.Add("MOV.F {}.w,{}.x;"
131 "{}.F{}{} {},{},{},2D;",
132 coords, bias_lc, op, lod_clamp, sparse_mod, ret, coords, texture);
133 }
134 if (sparse_inst) {
135 const Register sparse_ret{ctx.reg_alloc.Define(*sparse_inst)};
136 ctx.Add("MOV.S {},-1;"
137 "MOV.S {}(NONRESIDENT),0;",
138 sparse_ret, sparse_ret);
139 sparse_inst->Invalidate();
140 }
141}
142
143void EmitImageSampleExplicitLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
144 [[maybe_unused]] const IR::Value& index,
145 [[maybe_unused]] Register coords, [[maybe_unused]] Register lod_lc,
146 [[maybe_unused]] const IR::Value& offset) {
147 throw NotImplementedException("GLASM instruction");
148}
149
150void EmitImageSampleDrefImplicitLod([[maybe_unused]] EmitContext& ctx,
151 [[maybe_unused]] IR::Inst& inst,
152 [[maybe_unused]] const IR::Value& index,
153 [[maybe_unused]] Register coords,
154 [[maybe_unused]] Register dref,
155 [[maybe_unused]] Register bias_lc,
156 [[maybe_unused]] const IR::Value& offset) {
157 throw NotImplementedException("GLASM instruction");
158}
159
160void EmitImageSampleDrefExplicitLod([[maybe_unused]] EmitContext& ctx,
161 [[maybe_unused]] IR::Inst& inst,
162 [[maybe_unused]] const IR::Value& index,
163 [[maybe_unused]] Register coords,
164 [[maybe_unused]] Register dref,
165 [[maybe_unused]] Register lod_lc,
166 [[maybe_unused]] const IR::Value& offset) {
167 throw NotImplementedException("GLASM instruction");
168}
169
170void EmitImageGather([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
171 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
172 [[maybe_unused]] const IR::Value& offset,
173 [[maybe_unused]] const IR::Value& offset2) {
174 throw NotImplementedException("GLASM instruction");
175}
176
177void EmitImageGatherDref([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
178 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
179 [[maybe_unused]] const IR::Value& offset,
180 [[maybe_unused]] const IR::Value& offset2,
181 [[maybe_unused]] Register dref) {
182 throw NotImplementedException("GLASM instruction");
183}
184
185void EmitImageFetch([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
186 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
187 [[maybe_unused]] Register offset, [[maybe_unused]] Register lod,
188 [[maybe_unused]] Register ms) {
189 throw NotImplementedException("GLASM instruction");
190}
191
192void EmitImageQueryDimensions([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
193 [[maybe_unused]] const IR::Value& index,
194 [[maybe_unused]] Register lod) {
195 throw NotImplementedException("GLASM instruction");
196}
197
198void EmitImageQueryLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
199 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords) {
200 throw NotImplementedException("GLASM instruction");
201}
202
203void EmitImageGradient([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
204 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
205 [[maybe_unused]] Register derivates, [[maybe_unused]] Register offset,
206 [[maybe_unused]] Register lod_clamp) {
207 throw NotImplementedException("GLASM instruction");
208}
209
210void EmitImageRead([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
211 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords) {
212 throw NotImplementedException("GLASM instruction");
213}
214
215void EmitImageWrite([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
216 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
217 [[maybe_unused]] Register color) {
218 throw NotImplementedException("GLASM instruction");
219}
220
221} // namespace Shader::Backend::GLASM
diff --git a/src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp b/src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp
index e69de29bb..a0b9866de 100644
--- a/src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp
+++ b/src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp
@@ -0,0 +1,165 @@
1// Copyright 2021 yuzu Emulator Project
2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included.
4
5#include "shader_recompiler/backend/glasm/emit_context.h"
6#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
7#include "shader_recompiler/frontend/ir/value.h"
8
9namespace Shader::Backend::GLASM {
10
11void EmitBindlessImageAtomicIAdd32(EmitContext&) {
12 throw LogicError("Unreachable instruction");
13}
14
15void EmitBindlessImageAtomicSMin32(EmitContext&) {
16 throw LogicError("Unreachable instruction");
17}
18
19void EmitBindlessImageAtomicUMin32(EmitContext&) {
20 throw LogicError("Unreachable instruction");
21}
22
23void EmitBindlessImageAtomicSMax32(EmitContext&) {
24 throw LogicError("Unreachable instruction");
25}
26
27void EmitBindlessImageAtomicUMax32(EmitContext&) {
28 throw LogicError("Unreachable instruction");
29}
30
31void EmitBindlessImageAtomicInc32(EmitContext&) {
32 throw LogicError("Unreachable instruction");
33}
34
35void EmitBindlessImageAtomicDec32(EmitContext&) {
36 throw LogicError("Unreachable instruction");
37}
38
39void EmitBindlessImageAtomicAnd32(EmitContext&) {
40 throw LogicError("Unreachable instruction");
41}
42
43void EmitBindlessImageAtomicOr32(EmitContext&) {
44 throw LogicError("Unreachable instruction");
45}
46
47void EmitBindlessImageAtomicXor32(EmitContext&) {
48 throw LogicError("Unreachable instruction");
49}
50
51void EmitBindlessImageAtomicExchange32(EmitContext&) {
52 throw LogicError("Unreachable instruction");
53}
54
55void EmitBoundImageAtomicIAdd32(EmitContext&) {
56 throw LogicError("Unreachable instruction");
57}
58
59void EmitBoundImageAtomicSMin32(EmitContext&) {
60 throw LogicError("Unreachable instruction");
61}
62
63void EmitBoundImageAtomicUMin32(EmitContext&) {
64 throw LogicError("Unreachable instruction");
65}
66
67void EmitBoundImageAtomicSMax32(EmitContext&) {
68 throw LogicError("Unreachable instruction");
69}
70
71void EmitBoundImageAtomicUMax32(EmitContext&) {
72 throw LogicError("Unreachable instruction");
73}
74
75void EmitBoundImageAtomicInc32(EmitContext&) {
76 throw LogicError("Unreachable instruction");
77}
78
79void EmitBoundImageAtomicDec32(EmitContext&) {
80 throw LogicError("Unreachable instruction");
81}
82
83void EmitBoundImageAtomicAnd32(EmitContext&) {
84 throw LogicError("Unreachable instruction");
85}
86
87void EmitBoundImageAtomicOr32(EmitContext&) {
88 throw LogicError("Unreachable instruction");
89}
90
91void EmitBoundImageAtomicXor32(EmitContext&) {
92 throw LogicError("Unreachable instruction");
93}
94
95void EmitBoundImageAtomicExchange32(EmitContext&) {
96 throw LogicError("Unreachable instruction");
97}
98
99void EmitImageAtomicIAdd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
100 [[maybe_unused]] const IR::Value& index,
101 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
102 throw NotImplementedException("GLASM instruction");
103}
104
105void EmitImageAtomicSMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
106 [[maybe_unused]] const IR::Value& index,
107 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarS32 value) {
108 throw NotImplementedException("GLASM instruction");
109}
110
111void EmitImageAtomicUMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
112 [[maybe_unused]] const IR::Value& index,
113 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
114 throw NotImplementedException("GLASM instruction");
115}
116
117void EmitImageAtomicSMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
118 [[maybe_unused]] const IR::Value& index,
119 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarS32 value) {
120 throw NotImplementedException("GLASM instruction");
121}
122
123void EmitImageAtomicUMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
124 [[maybe_unused]] const IR::Value& index,
125 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
126 throw NotImplementedException("GLASM instruction");
127}
128
129void EmitImageAtomicInc32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
130 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
131 [[maybe_unused]] ScalarU32 value) {
132 throw NotImplementedException("GLASM instruction");
133}
134
135void EmitImageAtomicDec32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
136 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
137 [[maybe_unused]] ScalarU32 value) {
138 throw NotImplementedException("GLASM instruction");
139}
140
141void EmitImageAtomicAnd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
142 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
143 [[maybe_unused]] ScalarU32 value) {
144 throw NotImplementedException("GLASM instruction");
145}
146
147void EmitImageAtomicOr32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
148 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
149 [[maybe_unused]] ScalarU32 value) {
150 throw NotImplementedException("GLASM instruction");
151}
152
153void EmitImageAtomicXor32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
154 [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
155 [[maybe_unused]] ScalarU32 value) {
156 throw NotImplementedException("GLASM instruction");
157}
158
159void EmitImageAtomicExchange32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
160 [[maybe_unused]] const IR::Value& index,
161 [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
162 throw NotImplementedException("GLASM instruction");
163}
164
165} // namespace Shader::Backend::GLASM
diff --git a/src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp b/src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp
index 388b7eb02..a4c1ca481 100644
--- a/src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp
+++ b/src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp
@@ -228,303 +228,4 @@ void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
228 ctx.Add("SEQ.S {},{},0;", inst, value); 228 ctx.Add("SEQ.S {},{},0;", inst, value);
229} 229}
230 230
231void EmitBindlessImageSampleImplicitLod(EmitContext&) {
232 NotImplemented();
233}
234
235void EmitBindlessImageSampleExplicitLod(EmitContext&) {
236 NotImplemented();
237}
238
239void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
240 NotImplemented();
241}
242
243void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
244 NotImplemented();
245}
246
247void EmitBindlessImageGather(EmitContext&) {
248 NotImplemented();
249}
250
251void EmitBindlessImageGatherDref(EmitContext&) {
252 NotImplemented();
253}
254
255void EmitBindlessImageFetch(EmitContext&) {
256 NotImplemented();
257}
258
259void EmitBindlessImageQueryDimensions(EmitContext&) {
260 NotImplemented();
261}
262
263void EmitBindlessImageQueryLod(EmitContext&) {
264 NotImplemented();
265}
266
267void EmitBindlessImageGradient(EmitContext&) {
268 NotImplemented();
269}
270
271void EmitBindlessImageRead(EmitContext&) {
272 NotImplemented();
273}
274
275void EmitBindlessImageWrite(EmitContext&) {
276 NotImplemented();
277}
278
279void EmitBoundImageSampleImplicitLod(EmitContext&) {
280 NotImplemented();
281}
282
283void EmitBoundImageSampleExplicitLod(EmitContext&) {
284 NotImplemented();
285}
286
287void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
288 NotImplemented();
289}
290
291void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
292 NotImplemented();
293}
294
295void EmitBoundImageGather(EmitContext&) {
296 NotImplemented();
297}
298
299void EmitBoundImageGatherDref(EmitContext&) {
300 NotImplemented();
301}
302
303void EmitBoundImageFetch(EmitContext&) {
304 NotImplemented();
305}
306
307void EmitBoundImageQueryDimensions(EmitContext&) {
308 NotImplemented();
309}
310
311void EmitBoundImageQueryLod(EmitContext&) {
312 NotImplemented();
313}
314
315void EmitBoundImageGradient(EmitContext&) {
316 NotImplemented();
317}
318
319void EmitBoundImageRead(EmitContext&) {
320 NotImplemented();
321}
322
323void EmitBoundImageWrite(EmitContext&) {
324 NotImplemented();
325}
326
327void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
328 Register coords, Register bias_lc, const IR::Value& offset) {
329 NotImplemented();
330}
331
332void EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
333 Register coords, Register lod_lc, const IR::Value& offset) {
334 NotImplemented();
335}
336
337void EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
338 Register coords, Register dref, Register bias_lc,
339 const IR::Value& offset) {
340 NotImplemented();
341}
342
343void EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
344 Register coords, Register dref, Register lod_lc,
345 const IR::Value& offset) {
346 NotImplemented();
347}
348
349void EmitImageGather(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
350 const IR::Value& offset, const IR::Value& offset2) {
351 NotImplemented();
352}
353
354void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
355 const IR::Value& offset, const IR::Value& offset2, Register dref) {
356 NotImplemented();
357}
358
359void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
360 Register offset, Register lod, Register ms) {
361 NotImplemented();
362}
363
364void EmitImageQueryDimensions(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
365 Register lod) {
366 NotImplemented();
367}
368
369void EmitImageQueryLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords) {
370 NotImplemented();
371}
372
373void EmitImageGradient(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
374 Register derivates, Register offset, Register lod_clamp) {
375 NotImplemented();
376}
377
378void EmitImageRead(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords) {
379 NotImplemented();
380}
381
382void EmitImageWrite(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
383 Register color) {
384 NotImplemented();
385}
386
387void EmitBindlessImageAtomicIAdd32(EmitContext&) {
388 NotImplemented();
389}
390
391void EmitBindlessImageAtomicSMin32(EmitContext&) {
392 NotImplemented();
393}
394
395void EmitBindlessImageAtomicUMin32(EmitContext&) {
396 NotImplemented();
397}
398
399void EmitBindlessImageAtomicSMax32(EmitContext&) {
400 NotImplemented();
401}
402
403void EmitBindlessImageAtomicUMax32(EmitContext&) {
404 NotImplemented();
405}
406
407void EmitBindlessImageAtomicInc32(EmitContext&) {
408 NotImplemented();
409}
410
411void EmitBindlessImageAtomicDec32(EmitContext&) {
412 NotImplemented();
413}
414
415void EmitBindlessImageAtomicAnd32(EmitContext&) {
416 NotImplemented();
417}
418
419void EmitBindlessImageAtomicOr32(EmitContext&) {
420 NotImplemented();
421}
422
423void EmitBindlessImageAtomicXor32(EmitContext&) {
424 NotImplemented();
425}
426
427void EmitBindlessImageAtomicExchange32(EmitContext&) {
428 NotImplemented();
429}
430
431void EmitBoundImageAtomicIAdd32(EmitContext&) {
432 NotImplemented();
433}
434
435void EmitBoundImageAtomicSMin32(EmitContext&) {
436 NotImplemented();
437}
438
439void EmitBoundImageAtomicUMin32(EmitContext&) {
440 NotImplemented();
441}
442
443void EmitBoundImageAtomicSMax32(EmitContext&) {
444 NotImplemented();
445}
446
447void EmitBoundImageAtomicUMax32(EmitContext&) {
448 NotImplemented();
449}
450
451void EmitBoundImageAtomicInc32(EmitContext&) {
452 NotImplemented();
453}
454
455void EmitBoundImageAtomicDec32(EmitContext&) {
456 NotImplemented();
457}
458
459void EmitBoundImageAtomicAnd32(EmitContext&) {
460 NotImplemented();
461}
462
463void EmitBoundImageAtomicOr32(EmitContext&) {
464 NotImplemented();
465}
466
467void EmitBoundImageAtomicXor32(EmitContext&) {
468 NotImplemented();
469}
470
471void EmitBoundImageAtomicExchange32(EmitContext&) {
472 NotImplemented();
473}
474
475void EmitImageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
476 Register coords, ScalarU32 value) {
477 NotImplemented();
478}
479
480void EmitImageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
481 Register coords, ScalarS32 value) {
482 NotImplemented();
483}
484
485void EmitImageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
486 Register coords, ScalarU32 value) {
487 NotImplemented();
488}
489
490void EmitImageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
491 Register coords, ScalarS32 value) {
492 NotImplemented();
493}
494
495void EmitImageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
496 Register coords, ScalarU32 value) {
497 NotImplemented();
498}
499
500void EmitImageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
501 ScalarU32 value) {
502 NotImplemented();
503}
504
505void EmitImageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
506 ScalarU32 value) {
507 NotImplemented();
508}
509
510void EmitImageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
511 ScalarU32 value) {
512 NotImplemented();
513}
514
515void EmitImageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
516 ScalarU32 value) {
517 NotImplemented();
518}
519
520void EmitImageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
521 ScalarU32 value) {
522 NotImplemented();
523}
524
525void EmitImageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
526 Register coords, ScalarU32 value) {
527 NotImplemented();
528}
529
530} // namespace Shader::Backend::GLASM 231} // namespace Shader::Backend::GLASM
HIC SVNT DRACONES