Fix byref rewrite: load from addrspace(4) into alloca instead of addrspacecast

The addrspacecast from addrspace(4) to addrspace(0) caused "illegal
VGPR to SGPR copy" errors because LLVM couldn't properly lower
generic pointer accesses back to the constant address space.

Instead, follow Metal's approach: load the struct from the
addrspace(4) kernarg pointer into a local alloca (addrspace 5),
and let SROA decompose it during the optimization pipeline. This
avoids the address space mismatch while still benefiting from byref
semantics — the load from addrspace(4) is a scalar load from the
kernarg segment, and SROA will eliminate dead fields.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: gbaraldi

src/gcn.jl

@@ -46,13 +46,20 @@ pass_by_ref(@nospecialize(job::CompilerJob{GCNCompilerTarget})) = true
 const GCN_ADDRSPACE_CONSTANT = 4
 
 # Rewrite byref pointer parameters from addrspace 0 to addrspace 4 (kernarg),
-# inserting addrspacecasts so the function body can continue using generic pointers.
+# loading the data into local allocas so the function body can use generic pointers.
+# SROA will decompose the allocas during the optimization pipeline that follows.
 function rewrite_byref_addrspaces!(@nospecialize(job::CompilerJob{GCNCompilerTarget}),
                                    mod::LLVM.Module, f::LLVM.Function)
     ft = function_type(f)
 
-    # find byref parameters
+    # find byref parameters and their types
+    args = classify_arguments(job, ft)
+    filter!(args) do arg
+        arg.cc != GHOST
+    end
+
     byref = BitVector(undef, length(parameters(ft)))
+    byref_types = Vector{Any}(undef, length(parameters(ft)))
     for i in 1:length(byref)
         byref[i] = false
         for attr in collect(parameter_attributes(f, i))
@@ -61,6 +68,11 @@ function rewrite_byref_addrspaces!(@nospecialize(job::CompilerJob{GCNCompilerTar
             end
         end
     end
+    for arg in args
+        if arg.idx !== nothing && byref[arg.idx]
+            byref_types[arg.idx] = arg.typ
+        end
+    end
     any(byref) || return f
 
     # build new function type with addrspace(4) pointers for byref params
@@ -87,16 +99,21 @@ function rewrite_byref_addrspaces!(@nospecialize(job::CompilerJob{GCNCompilerTar
         end
     end
 
-    # insert addrspacecasts in entry block
+    # load byref arguments from addrspace(4) into local allocas
     new_args = LLVM.Value[]
     @dispose builder=IRBuilder() begin
         entry = BasicBlock(new_f, "conversion")
         position!(builder, entry)
 
         for (i, param) in enumerate(parameters(ft))
             if byref[i]
-                # cast from addrspace(4) to addrspace(0) for the function body
-                ptr = addrspacecast!(builder, parameters(new_f)[i], param)
+                # load the value from the kernarg pointer and store into a stack slot,
+                # so the function body can keep using addrspace(0) pointers.
+                # SROA will decompose this during optimization.
+                llvm_typ = convert(LLVMType, byref_types[i])
+                val = load!(builder, llvm_typ, parameters(new_f)[i])
+                ptr = alloca!(builder, llvm_typ)
+                store!(builder, val, ptr)
                 push!(new_args, ptr)
             else
                 push!(new_args, parameters(new_f)[i])