[vchuravy]

Stacked on #24. These fixes come from running GPUCompiler's test suite with codegen=:juliacodegen (JuliaGPU/GPUCompiler.jl#1036). Each commit makes JuliaCodegen.jl emit what native code emits where GPUCompiler (or its tests) depends on it.

On Julia 1.12, the whole GPUCompiler suite went from 149 failures and 15 errors to 10 failures and no errors (4446 of 4460 pass; Julia's own code generator: 4456). The 10 that remain are IR-shape tests, listed at the end.

Conventions

• specsig, varargs methods: take their arguments one by one, as native code passes them. A signature ending in Vararg is still called in the jlcall convention.
• specsig, union results: as native code's union results. A member without references comes back as its type index, with its data in the union_bytes_return buffer. A union of singletons comes back as just the index. Others come back boxed. A value that has a box (a constant) is returned as that box, with UNION_BOX_MARKER. This holds for our specsig entries and for our calls of specsig functions (cfunction, jlcall entries). From Julia 1.14 on (implement sret_union ABI for pointer-ful types JuliaLang/julia#55045), members with references are also returned unboxed: their bytes go in the buffer, and their references go in a return_roots argument marked julia.return_roots, which GC lowering roots in the caller's stack slots. This is keyed on JuliaIR's dialect.gc_return_roots === :attribute.
• Inline aggregates by reference: functions take inline aggregates without references by reference (ptr addrspace(11), readonly), as native code's specsig functions do. Values keep the memory they were loaded from (a reference argument, an immutable box). Calls pass that memory on instead of copying to the stack, and dynamic indices read in place.
• jlcall entries: they call the specsig entry, as jfptr_f_N calls julia_f_N, instead of inlining the function. They have native code's attributes: a nonnull result and a noalias nocapture noundef readonly argument array.
• @noinline methods: their functions are noinline.

Builtins and intrinsics

• getfield with an index known only at run time (emit_getfield_unknownidx), on:

  • inline tuples of a single type: extracted from a vector, selected among a few elements, or loaded from memory;
  • tuples of references;
  • objects whose fields are all references, or all of one type.

  Constants are read from a private global, which GPU back ends place in constant memory.

• Core.svec, allocated inline (as native code from 1.12 on), and Core._svec_len.

• Atomic fields: loads with an order, and modifications as a cmpxchg loop.

• Fast-math flags on the _fast intrinsics.

• throw goes through jl_throw even where inference knows the call throws.

Error paths through the runtime

These replace calls of Julia functions that construct the exceptions, which allocate on GPU back ends, where these throws lower to traps:

• bounds errors: jl_bounds_error_int with the boxed value, or jl_bounds_error_unboxed_int with the data of an inline value without references;
• undefined references and division by zero: the runtime's exception objects, through jl_throw;
• undefined locals: jl_undefined_var_error;
• llvmcall of an unknown name: jl_error;
• type checks of pointerset values: jl_type_error.

llvmcall and ccall

• Base.llvmcall passes Ptr values as integers of their size, and structs of fields of one type as arrays, as native code does. Only ccall(…, llvmcall, …) passes LLVM structs.
• llvmcall convention: extern functions, and overloads of intrinsics by their base name.
• Runtime symbols go through their ijl_ aliases. Other symbols are bound lazily, as native code does: jlplt_<sym>_N_got slots, and jl_dlfind for the runtime's libraries.

Objects and globals

• The runtime's objects (jl_true, jl_nothing, …) through the runtime's globals.
• Types with a small tag from their entry in jl_small_typeof.
• Other objects' globals are named as native code's (+Mod.T#N, -Mod.f#N, jl_sym#s#N, jl_global#N) and carry julia.constgv. GPUCompiler derives relocation names from these.
• Unions keep the box of a constant member, or the box a value came from.
• Other modules' bindings are read through the runtime. Typed assignments go through the binding.

Debug information

• The statement index in the column, from Julia 1.14 on, as native code.
• Linkage names are the specsig entries' names.
• debug_info=:no_debug emits locations in a compile unit of emission kind NoDebug, as native code does for debug_info_kind NoDebug (unless Julia runs with -g0). GPUCompiler's backtraces need these on PTX.

GPUCompiler tests that still fail (IR shape)

• nested insertvalue (SPIR-V, 4): native code's nested-index insertvalues come from SROA of aggregates built in stack memory. JuliaCodegen.jl builds them in SSA, and LLVM's C API can't emit nested indices.
• replace i128 allocas (SPIR-V, 4): native code returns the aggregate through sret into a stack slot. JuliaCodegen.jl's internal convention returns it by value, so there is no alloca to rewrite.
• merged relocation slots (Metal): native code loads an object's address where it is used, and LLVM merges those loads into one from a phi of slots. JuliaCodegen.jl loads each once, at the top of the function.
• smalltag boxed union constant demotion (Metal): internal calls carry the union's payload, so the kernel never reads the constant's box, and nothing needs to be demoted to an alloca.

Tests

Every fix has tests (differential runs, and FileCheck where the shape is the point). Tested locally with julia +1.12, +1.13, +1.14-nightly and +nightly: 6114, 6120, 6120 and 6120 tests pass. On nightly, one allocation-count check in memory.jl failed only while two suites ran at once, and passes on its own.

🤖 Generated with Claude Code