8 files changed, 79 insertions, 30 deletions

diff --git a/src/shader_recompiler/backend/glsl/emit_context.cpp b/src/shader_recompiler/backend/glsl/emit_context.cpp
index 0dcdff152..e08d2d2eb 100644
--- a/src/shader_recompiler/backend/glsl/emit_context.cpp
+++ b/src/shader_recompiler/backend/glsl/emit_context.cpp
@@ -378,7 +378,7 @@ void EmitContext::SetupExtensions() {
     if (info.uses_shadow_lod && profile.support_gl_texture_shadow_lod) {
         header += "#extension GL_EXT_texture_shadow_lod : enable\n";
     }
-    if (info.uses_int64) {
+    if (info.uses_int64 && profile.support_int64) {
         header += "#extension GL_ARB_gpu_shader_int64 : enable\n";
     }
     if (info.uses_int64_bit_atomics) {
@@ -402,7 +402,7 @@ void EmitContext::SetupExtensions() {
         info.uses_subgroup_shuffles || info.uses_fswzadd) {
         header += "#extension GL_ARB_shader_ballot : enable\n"
                   "#extension GL_ARB_shader_group_vote : enable\n";
-        if (!info.uses_int64) {
+        if (!info.uses_int64 && profile.support_int64) {
             header += "#extension GL_ARB_gpu_shader_int64 : enable\n";
         }
         if (profile.support_gl_warp_intrinsics) {
@@ -539,7 +539,7 @@ void EmitContext::DefineHelperFunctions() {
     if (info.uses_atomic_s32_max) {
         header += "uint CasMaxS32(uint op_a,uint op_b){return uint(max(int(op_a),int(op_b)));}";
     }
-    if (info.uses_global_memory) {
+    if (info.uses_global_memory && profile.support_int64) {
         header += DefineGlobalMemoryFunctions();
     }
     if (info.loads_indexed_attributes) {
diff --git a/src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp b/src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp
index daef5fb84..e3957491f 100644
--- a/src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp
+++ b/src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp
@@ -7,6 +7,7 @@
 #include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
 #include "shader_recompiler/frontend/ir/value.h"
+#include "shader_recompiler/profile.h"
 
 namespace Shader::Backend::GLSL {
 namespace {
@@ -38,15 +39,27 @@ void EmitLoadGlobalS16(EmitContext&) {
 }
 
 void EmitLoadGlobal32(EmitContext& ctx, IR::Inst& inst, std::string_view address) {
-    ctx.AddU32("{}=LoadGlobal32({});", inst, address);
+    if (ctx.profile.support_int64) {
+        return ctx.AddU32("{}=LoadGlobal32({});", inst, address);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
+    ctx.AddU32("{}=0u;", inst);
 }
 
 void EmitLoadGlobal64(EmitContext& ctx, IR::Inst& inst, std::string_view address) {
-    ctx.AddU32x2("{}=LoadGlobal64({});", inst, address);
+    if (ctx.profile.support_int64) {
+        return ctx.AddU32x2("{}=LoadGlobal64({});", inst, address);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
+    ctx.AddU32x2("{}=uvec2(0);", inst);
 }
 
 void EmitLoadGlobal128(EmitContext& ctx, IR::Inst& inst, std::string_view address) {
-    ctx.AddU32x4("{}=LoadGlobal128({});", inst, address);
+    if (ctx.profile.support_int64) {
+        return ctx.AddU32x4("{}=LoadGlobal128({});", inst, address);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
+    ctx.AddU32x4("{}=uvec4(0);", inst);
 }
 
 void EmitWriteGlobalU8(EmitContext&) {
@@ -66,15 +79,24 @@ void EmitWriteGlobalS16(EmitContext&) {
 }
 
 void EmitWriteGlobal32(EmitContext& ctx, std::string_view address, std::string_view value) {
-    ctx.Add("WriteGlobal32({},{});", address, value);
+    if (ctx.profile.support_int64) {
+        return ctx.Add("WriteGlobal32({},{});", address, value);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
 }
 
 void EmitWriteGlobal64(EmitContext& ctx, std::string_view address, std::string_view value) {
-    ctx.Add("WriteGlobal64({},{});", address, value);
+    if (ctx.profile.support_int64) {
+        return ctx.Add("WriteGlobal64({},{});", address, value);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
 }
 
 void EmitWriteGlobal128(EmitContext& ctx, std::string_view address, std::string_view value) {
-    ctx.Add("WriteGlobal128({},{});", address, value);
+    if (ctx.profile.support_int64) {
+        return ctx.Add("WriteGlobal128({},{});", address, value);
+    }
+    LOG_WARNING(Shader_GLSL, "Int64 not supported, ignoring memory operation");
 }
 
 void EmitLoadStorageU8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
diff --git a/src/shader_recompiler/backend/spirv/emit_context.cpp b/src/shader_recompiler/backend/spirv/emit_context.cpp
index 865f34291..2d29d8c14 100644
--- a/src/shader_recompiler/backend/spirv/emit_context.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_context.cpp
@@ -830,7 +830,7 @@ void EmitContext::DefineAttributeMemAccess(const Info& info) {
 }
 
 void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
-    if (!info.uses_global_memory) {
+    if (!info.uses_global_memory || !profile.support_int64) {
         return;
     }
     using DefPtr = Id StorageDefinitions::*;
diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp
index ccebf170d..679ee2684 100644
--- a/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp
@@ -84,15 +84,27 @@ void EmitLoadGlobalS16(EmitContext&) {
 }
 
 Id EmitLoadGlobal32(EmitContext& ctx, Id address) {
-    return ctx.OpFunctionCall(ctx.U32[1], ctx.load_global_func_u32, address);
+    if (ctx.profile.support_int64) {
+        return ctx.OpFunctionCall(ctx.U32[1], ctx.load_global_func_u32, address);
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
+    return ctx.Const(0u);
 }
 
 Id EmitLoadGlobal64(EmitContext& ctx, Id address) {
-    return ctx.OpFunctionCall(ctx.U32[2], ctx.load_global_func_u32x2, address);
+    if (ctx.profile.support_int64) {
+        return ctx.OpFunctionCall(ctx.U32[2], ctx.load_global_func_u32x2, address);
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
+    return ctx.Const(0u, 0u);
 }
 
 Id EmitLoadGlobal128(EmitContext& ctx, Id address) {
-    return ctx.OpFunctionCall(ctx.U32[4], ctx.load_global_func_u32x4, address);
+    if (ctx.profile.support_int64) {
+        return ctx.OpFunctionCall(ctx.U32[4], ctx.load_global_func_u32x4, address);
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
+    return ctx.Const(0u, 0u, 0u, 0u);
 }
 
 void EmitWriteGlobalU8(EmitContext&) {
@@ -112,15 +124,27 @@ void EmitWriteGlobalS16(EmitContext&) {
 }
 
 void EmitWriteGlobal32(EmitContext& ctx, Id address, Id value) {
-    ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32, address, value);
+    if (ctx.profile.support_int64) {
+        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32, address, value);
+        return;
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
 }
 
 void EmitWriteGlobal64(EmitContext& ctx, Id address, Id value) {
-    ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x2, address, value);
+    if (ctx.profile.support_int64) {
+        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x2, address, value);
+        return;
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
 }
 
 void EmitWriteGlobal128(EmitContext& ctx, Id address, Id value) {
-    ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x4, address, value);
+    if (ctx.profile.support_int64) {
+        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x4, address, value);
+        return;
+    }
+    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
 }
 
 Id EmitLoadStorageU8(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
diff --git a/src/shader_recompiler/frontend/ir/opcodes.inc b/src/shader_recompiler/frontend/ir/opcodes.inc
index 9af750283..d91098c80 100644
--- a/src/shader_recompiler/frontend/ir/opcodes.inc
+++ b/src/shader_recompiler/frontend/ir/opcodes.inc
@@ -71,20 +71,20 @@ OPCODE(UndefU32,                                            U32,
 OPCODE(UndefU64,                                            U64,                                                                                            )
 
 // Memory operations
-OPCODE(LoadGlobalU8,                                        U32,            U64,                                                                            )
-OPCODE(LoadGlobalS8,                                        U32,            U64,                                                                            )
-OPCODE(LoadGlobalU16,                                       U32,            U64,                                                                            )
-OPCODE(LoadGlobalS16,                                       U32,            U64,                                                                            )
-OPCODE(LoadGlobal32,                                        U32,            U64,                                                                            )
-OPCODE(LoadGlobal64,                                        U32x2,          U64,                                                                            )
-OPCODE(LoadGlobal128,                                       U32x4,          U64,                                                                            )
-OPCODE(WriteGlobalU8,                                       Void,           U64,            U32,                                                            )
-OPCODE(WriteGlobalS8,                                       Void,           U64,            U32,                                                            )
-OPCODE(WriteGlobalU16,                                      Void,           U64,            U32,                                                            )
-OPCODE(WriteGlobalS16,                                      Void,           U64,            U32,                                                            )
-OPCODE(WriteGlobal32,                                       Void,           U64,            U32,                                                            )
-OPCODE(WriteGlobal64,                                       Void,           U64,            U32x2,                                                          )
-OPCODE(WriteGlobal128,                                      Void,           U64,            U32x4,                                                          )
+OPCODE(LoadGlobalU8,                                        U32,            Opaque,                                                                         )
+OPCODE(LoadGlobalS8,                                        U32,            Opaque,                                                                         )
+OPCODE(LoadGlobalU16,                                       U32,            Opaque,                                                                         )
+OPCODE(LoadGlobalS16,                                       U32,            Opaque,                                                                         )
+OPCODE(LoadGlobal32,                                        U32,            Opaque,                                                                         )
+OPCODE(LoadGlobal64,                                        U32x2,          Opaque,                                                                         )
+OPCODE(LoadGlobal128,                                       U32x4,          Opaque,                                                                         )
+OPCODE(WriteGlobalU8,                                       Void,           Opaque,         U32,                                                            )
+OPCODE(WriteGlobalS8,                                       Void,           Opaque,         U32,                                                            )
+OPCODE(WriteGlobalU16,                                      Void,           Opaque,         U32,                                                            )
+OPCODE(WriteGlobalS16,                                      Void,           Opaque,         U32,                                                            )
+OPCODE(WriteGlobal32,                                       Void,           Opaque,         U32,                                                            )
+OPCODE(WriteGlobal64,                                       Void,           Opaque,         U32x2,                                                          )
+OPCODE(WriteGlobal128,                                      Void,           Opaque,         U32x4,                                                          )
 
 // Storage buffer operations
 OPCODE(LoadStorageU8,                                       U32,            U32,            U32,                                                            )
diff --git a/src/shader_recompiler/profile.h b/src/shader_recompiler/profile.h
index 6ff12387b..501dcaf71 100644
--- a/src/shader_recompiler/profile.h
+++ b/src/shader_recompiler/profile.h
@@ -15,6 +15,7 @@ struct Profile {
     bool support_descriptor_aliasing{};
     bool support_int8{};
     bool support_int16{};
+    bool support_int64{};
     bool support_vertex_instance_id{};
     bool support_float_controls{};
     bool support_separate_denorm_behavior{};
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index 2d7eb3e33..58a4f0fb4 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -168,6 +168,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .support_descriptor_aliasing = false,
           .support_int8 = false,
           .support_int16 = false,
+          .support_int64 = device.HasShaderInt64(),
           .support_vertex_instance_id = true,
           .support_float_controls = false,
           .support_separate_denorm_behavior = false,
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 87b843e3d..a2646fc6d 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -280,6 +280,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, Tegra::Engines::Maxw
         .support_descriptor_aliasing = true,
         .support_int8 = true,
         .support_int16 = device.IsShaderInt16Supported(),
+        .support_int64 = device.IsShaderInt64Supported(),
         .support_vertex_instance_id = false,
         .support_float_controls = true,
         .support_separate_denorm_behavior = float_control.denormBehaviorIndependence ==