diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 89a02d46b2a225999809fabe37c82f50527a348e..2722d5d62f0cbf7503aadda61ac5e23e28bd5967 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -542,10 +542,13 @@ pub const DataLayout = struct {
                     "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
             },
             .spirv32 => switch (target.os.tag) {
-                .vulkan, .opengl => "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-G1",
-                else => "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-G1",
+                .vulkan, .opengl => "e-ve-i64:64-n8:16:32:64-G10",
+                else => "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64-G1",
             },
-            .spirv64 => "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-G1",
+            .spirv64 => if (target.os.tag == .amdhsa)
+                "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n32:64-S32-G1-P4-A0"
+            else
+                "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64-G1",
             .wasm32 => if (target.os.tag == .emscripten)
                 "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-f128:64-n32:64-S128-ni:1:10:20"
             else
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index a309d9cc20ec1d4394791f34eb80f2f02a7d0fe9..f4198c2db8da81c76fcb743e8e5dd972ede77bef 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -4452,26 +4452,6 @@ pub fn toLlvmAddressSpace(address_space: std.lang.AddressSpace, target: *const s
     };
 }
 
-/// On some targets, global values that are in the generic address space must be generated into a
-/// different address space, and then cast back to the generic address space.
-fn llvmDefaultGlobalAddressSpace(target: *const std.Target) Builder.AddrSpace {
-    return switch (target.cpu.arch) {
-        // On amdgcn, globals must be explicitly allocated and uploaded so that the program can access
-        // them.
-        .amdgcn => Builder.AddrSpace.amdgpu.global,
-        else => .default,
-    };
-}
-
-/// Return the actual address space that a value should be stored in if its a global address space.
-/// When a value is placed in the resulting address space, it needs to be cast back into wanted_address_space.
-fn toLlvmGlobalAddressSpace(wanted_address_space: std.lang.AddressSpace, target: *const std.Target) Builder.AddrSpace {
-    return switch (wanted_address_space) {
-        .generic => llvmDefaultGlobalAddressSpace(target),
-        else => |as| toLlvmAddressSpace(as, target),
-    };
-}
-
 /// We need to insert extra padding if LLVM's isn't enough.
 /// However we don't want to ever call LLVMABIAlignmentOfType or
 /// LLVMABISizeOfType because these functions will trip assertions
diff --git a/test/llvm_targets.zig b/test/llvm_targets.zig
index 78c775a34bdb5666c244984b4bbc7efaa440b2df..0c758566fe37fc1af4862620f36dda3d17a9dc0d 100644
--- a/test/llvm_targets.zig
+++ b/test/llvm_targets.zig
@@ -260,6 +260,13 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .sparc64, .os_tag = .openbsd, .abi = .none },
     .{ .cpu_arch = .sparc64, .os_tag = .rtems, .abi = .none },
 
+    // .{ .cpu_arch = .spirv32, .os_tag = .opencl, .abi = .none },
+    // .{ .cpu_arch = .spirv32, .os_tag = .opengl, .abi = .none },
+    // .{ .cpu_arch = .spirv32, .os_tag = .vulkan, .abi = .none },
+    // .{ .cpu_arch = .spirv64, .os_tag = .amdhsa, .abi = .none },
+    // .{ .cpu_arch = .spirv64, .os_tag = .opencl, .abi = .none },
+    // .{ .cpu_arch = .spirv64, .os_tag = .vulkan, .abi = .none },
+
     .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabi },
     .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabihf },
     .{ .cpu_arch = .thumb, .os_tag = .fuchsia, .abi = .eabihf },