glasm: Initial (broken) implementation of TEX on GLASM

src/shader_recompiler/backend/glasm/emit_glasm_image.cpp

@@ -0,0 +1,221 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_context.h"
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/frontend/ir/modifiers.h"
+#include "shader_recompiler/frontend/ir/value.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitBindlessImageSampleImplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageSampleExplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageGather(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageGatherDref(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageFetch(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageQueryDimensions(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageQueryLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageGradient(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageRead(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageWrite(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageSampleImplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageSampleExplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageGather(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageGatherDref(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageFetch(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageQueryDimensions(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageQueryLod(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageGradient(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageRead(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageWrite(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+std::string Texture([[maybe_unused]] EmitContext& ctx, IR::TextureInstInfo info,
+                    [[maybe_unused]] const IR::Value& index) {
+    // FIXME
+    return fmt::format("texture[{}]", info.descriptor_index);
+}
+
+void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
+                                Register coords, Register bias_lc,
+                                [[maybe_unused]] const IR::Value& offset) {
+    const auto info{inst.Flags<IR::TextureInstInfo>()};
+    const auto sparse_inst{inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp)};
+    const std::string_view op{info.has_bias ? "TXB" : "TEX"};
+    const std::string_view lod_clamp{info.has_lod_clamp ? ".LODCLAMP" : ""};
+    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
+    const std::string texture{Texture(ctx, info, index)};
+    const Register ret{ctx.reg_alloc.Define(inst)};
+    // FIXME
+    const bool separate{info.type == TextureType::ColorArrayCube};
+    if (separate) {
+        ctx.Add("{}.F{}{} {},{},{},{},2D;", op, lod_clamp, sparse_mod, ret, coords, bias_lc,
+                texture);
+    } else {
+        ctx.Add("MOV.F {}.w,{}.x;"
+                "{}.F{}{} {},{},{},2D;",
+                coords, bias_lc, op, lod_clamp, sparse_mod, ret, coords, texture);
+    }
+    if (sparse_inst) {
+        const Register sparse_ret{ctx.reg_alloc.Define(*sparse_inst)};
+        ctx.Add("MOV.S {},-1;"
+                "MOV.S {}(NONRESIDENT),0;",
+                sparse_ret, sparse_ret);
+        sparse_inst->Invalidate();
+    }
+}
+
+void EmitImageSampleExplicitLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                                [[maybe_unused]] const IR::Value& index,
+                                [[maybe_unused]] Register coords, [[maybe_unused]] Register lod_lc,
+                                [[maybe_unused]] const IR::Value& offset) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageSampleDrefImplicitLod([[maybe_unused]] EmitContext& ctx,
+                                    [[maybe_unused]] IR::Inst& inst,
+                                    [[maybe_unused]] const IR::Value& index,
+                                    [[maybe_unused]] Register coords,
+                                    [[maybe_unused]] Register dref,
+                                    [[maybe_unused]] Register bias_lc,
+                                    [[maybe_unused]] const IR::Value& offset) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageSampleDrefExplicitLod([[maybe_unused]] EmitContext& ctx,
+                                    [[maybe_unused]] IR::Inst& inst,
+                                    [[maybe_unused]] const IR::Value& index,
+                                    [[maybe_unused]] Register coords,
+                                    [[maybe_unused]] Register dref,
+                                    [[maybe_unused]] Register lod_lc,
+                                    [[maybe_unused]] const IR::Value& offset) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageGather([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                     [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                     [[maybe_unused]] const IR::Value& offset,
+                     [[maybe_unused]] const IR::Value& offset2) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageGatherDref([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                         [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                         [[maybe_unused]] const IR::Value& offset,
+                         [[maybe_unused]] const IR::Value& offset2,
+                         [[maybe_unused]] Register dref) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageFetch([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                    [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                    [[maybe_unused]] Register offset, [[maybe_unused]] Register lod,
+                    [[maybe_unused]] Register ms) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageQueryDimensions([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                              [[maybe_unused]] const IR::Value& index,
+                              [[maybe_unused]] Register lod) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageQueryLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                       [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageGradient([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                       [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                       [[maybe_unused]] Register derivates, [[maybe_unused]] Register offset,
+                       [[maybe_unused]] Register lod_clamp) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageRead([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                   [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageWrite([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                    [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                    [[maybe_unused]] Register color) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_image_atomic.cpp

@@ -0,0 +1,165 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_context.h"
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/frontend/ir/value.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitBindlessImageAtomicIAdd32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicSMin32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicUMin32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicSMax32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicUMax32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicInc32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicDec32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicAnd32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicOr32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicXor32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBindlessImageAtomicExchange32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicIAdd32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicSMin32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicUMin32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicSMax32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicUMax32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicInc32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicDec32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicAnd32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicOr32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicXor32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitBoundImageAtomicExchange32(EmitContext&) {
+    throw LogicError("Unreachable instruction");
+}
+
+void EmitImageAtomicIAdd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                           [[maybe_unused]] const IR::Value& index,
+                           [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicSMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                           [[maybe_unused]] const IR::Value& index,
+                           [[maybe_unused]] Register coords, [[maybe_unused]] ScalarS32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicUMin32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                           [[maybe_unused]] const IR::Value& index,
+                           [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicSMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                           [[maybe_unused]] const IR::Value& index,
+                           [[maybe_unused]] Register coords, [[maybe_unused]] ScalarS32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicUMax32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                           [[maybe_unused]] const IR::Value& index,
+                           [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicInc32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                          [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicDec32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                          [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicAnd32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                          [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicOr32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                         [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                         [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicXor32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                          [[maybe_unused]] const IR::Value& index, [[maybe_unused]] Register coords,
+                          [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+void EmitImageAtomicExchange32([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
+                               [[maybe_unused]] const IR::Value& index,
+                               [[maybe_unused]] Register coords, [[maybe_unused]] ScalarU32 value) {
+    throw NotImplementedException("GLASM instruction");
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp

@@ -228,303 +228,4 @@ void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
     ctx.Add("SEQ.S {},{},0;", inst, value);
 }
 
-void EmitBindlessImageSampleImplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageSampleExplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageGather(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageGatherDref(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageFetch(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageQueryDimensions(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageQueryLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageGradient(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageRead(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageWrite(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageSampleImplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageSampleExplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageGather(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageGatherDref(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageFetch(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageQueryDimensions(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageQueryLod(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageGradient(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageRead(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageWrite(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                Register coords, Register bias_lc, const IR::Value& offset) {
-    NotImplemented();
-}
-
-void EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                Register coords, Register lod_lc, const IR::Value& offset) {
-    NotImplemented();
-}
-
-void EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    Register coords, Register dref, Register bias_lc,
-                                    const IR::Value& offset) {
-    NotImplemented();
-}
-
-void EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    Register coords, Register dref, Register lod_lc,
-                                    const IR::Value& offset) {
-    NotImplemented();
-}
-
-void EmitImageGather(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                     const IR::Value& offset, const IR::Value& offset2) {
-    NotImplemented();
-}
-
-void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                         const IR::Value& offset, const IR::Value& offset2, Register dref) {
-    NotImplemented();
-}
-
-void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                    Register offset, Register lod, Register ms) {
-    NotImplemented();
-}
-
-void EmitImageQueryDimensions(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                              Register lod) {
-    NotImplemented();
-}
-
-void EmitImageQueryLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords) {
-    NotImplemented();
-}
-
-void EmitImageGradient(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                       Register derivates, Register offset, Register lod_clamp) {
-    NotImplemented();
-}
-
-void EmitImageRead(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords) {
-    NotImplemented();
-}
-
-void EmitImageWrite(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                    Register color) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicIAdd32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicSMin32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicUMin32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicSMax32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicUMax32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicInc32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicDec32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicAnd32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicOr32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicXor32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBindlessImageAtomicExchange32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicIAdd32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicSMin32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicUMin32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicSMax32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicUMax32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicInc32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicDec32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicAnd32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicOr32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicXor32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitBoundImageAtomicExchange32(EmitContext&) {
-    NotImplemented();
-}
-
-void EmitImageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                           Register coords, ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                           Register coords, ScalarS32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                           Register coords, ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                           Register coords, ScalarS32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                           Register coords, ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                          ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                          ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                          ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                         ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coords,
-                          ScalarU32 value) {
-    NotImplemented();
-}
-
-void EmitImageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                               Register coords, ScalarU32 value) {
-    NotImplemented();
-}
-
 } // namespace Shader::Backend::GLASM