[vchuravy]

Stacked on #18. This is the GPUCompiler.jl/Enzyme.jl entry point (plan P4), the JuliaCodegen counterpart of the jl_emit_native call in GPUCompiler's compile_method_instance.

compiled, output = JuliaCodegen.emit_into!(mod, codeinfos; config)
# codeinfos: (CodeInstance, CodeInfo or IRCode) pairs, e.g. from CompilerCaching.get_codeinfos
# compiled[ci] :: CompiledFunctions(func, specfunc)   # jlcall and specsig entry names
# output       :: CodegenOutput                       # literals to bind, symbols, fallbacks

There is also emit_into!(cgm, codeinfos) for an existing CGModule.

• IR source: each function's IR comes from the set (inflate_ir for a CodeInfo), with its CodeInstance's rettype. :invokes of the set's CodeInstances call their functions.
• Callees outside the set follow on_unsupported: with :fallback they call native code and are recorded in output.fallbacks; with :error they throw.
• Always-throwing functions are compiled rather than stubbed. Device code can't call native code.
• Entries: every CodeInstance gets a jlcall entry and, where specsig_abi handles the signature, a specsig entry. Both have external linkage; the bodies are internal. GPUCompiler reads the same func/specfunc pair from jl_emit_native today.

Supporting changes

• CGModule(mod, config; ir_source=get_ir, throwing_stubs=true). A callee whose IR the source can't provide now follows the failure policy instead of always becoming a stub. The existing suite is unaffected.
• CodegenConfig(; gcstack_arg=true, safepoint_on_entry=true) mirrors Julia's CodegenParams. GPUCompiler sets both to false. With gcstack_arg=false, specsig entries have no pgcstack argument and use the C calling convention. @cfunction always uses the runtime's convention, which passes the pgcstack.

Tests (test/emit_into.jl)

They use a small AbstractInterpreter with an overlay method table, standing in for GPUCompiler's, plus a transitive (ci, src) collector.

• The caller's IR is the one compiled: with the overlay, ei_kernel(3) == 602; native gives 8.
• Differential corpus through emit_into!: recursion, loops over arrays, error paths, try/catch, aggregates.
• Entries and linkage: checked, and an always-throwing callee is compiled.
• GPU-style config: specsig declarations match native code_llvm with CodegenParams(gcstack_arg=false, safepoint_on_entry=false), and the code has no safepoints. The specsig entry is called directly with ccall as a C function.
• Closed set: a missing callee throws or falls back depending on the policy, and duplicate method instances are rejected.

Known gap: varargs callees (e.g. string interpolation in an error message) are still stubs that call native code. They show up in output.fallbacks.

Tested locally with julia +1.12, +1.13 and +nightly: 6935, 6941 and 6940 tests pass.

🤖 Generated with Claude Code