Metal: extend address-space inference across call arguments

[maleadt]

Problem

InferAddressSpaces is intraprocedural. A pointer that reaches a load through a function parameter is invisible to it, because the parameter's address space was established at the call site, one frame up. On Metal that gap is fatal: a constant global GPUCompiler reads through an out-of-line runtime function (the exception reporters, the -g2 debug strings) arrives as a generic pointer and is read with a generic-space load, and the shader validator crashes on it.

At -g2 the deduced exception name lives in the constant space, but the reporter still reads it through a generic parameter:

@exception = private addrspace(2) constant [10 x i8] c"exception\00"

; caller
call void @report_exception(ptr addrspacecast (ptr addrspace(2) @exception to ptr))

define internal void @report_exception(ptr %ex) {
  %c = load i8, ptr %ex          ; generic load: validator crashes
}

add_global_address_spaces! already placed the string in addrspace(2), but the cast back to generic at the call site is exactly the provenance InferAddressSpaces cannot follow into the callee.

Solution

propagate_argument_address_spaces! supplies the missing call-edge inference. When every caller passes the same addrspacecast(specific -> generic) for a generic pointer parameter of an internal function, it retargets the parameter to that space, recreates the cast on entry so the body is untouched, and passes the source directly at the call sites:

; caller
call void @report_exception(ptr addrspace(2) @exception)

define internal void @report_exception(ptr addrspace(2) %ex) {
  %gen = addrspacecast ptr addrspace(2) %ex to ptr   ; recreated on entry
  %c = load i8, ptr %gen
}

The InferAddressSpaces run that already follows then finishes the job intraprocedurally, folding the entry cast away:

define internal void @report_exception(ptr addrspace(2) %ex) {
  %c = load i8, ptr addrspace(2) %ex                 ; constant-space load
}

The two together give whole-program inference for the case where all callers agree on the source space.