[vchuravy]

Stacked on #19. This completes plan P4's drivers. The runtime hook remains, on its own stack.

jit = JuliaCodegen.JIT(; config=CodegenConfig(), pipeline=JuliaCppPipeline(), relocatable=true)
jf  = JuliaCodegen.jit_compile(jit, Tuple{typeof(f), Int})   # ::JITFunction (ci, fptr, specptr, fallbacks)
jf(f, 3)                                                      # through the jlcall entry
JuliaCodegen.jit_call(jit, f, 3)

It uses no unmerged Julia API; everything goes through LLVM.jl's JuliaOJIT.

• IR: JITInterpreter is native inference with a cache owner of its own (:JuliaCodegen). Its CodeInstances keep uncompressed sources (may_discard_trees/may_compress are false). collect_codeinfos(interp, mi) gathers the closed set that the call :invokes. Functions with a constant result have no kept source, so they are re-inferred with typeinf_code. Varargs callees are left to the runtime. emit_into! (emit_into!: compile a closed set of CodeInstances into the caller's module #19) compiles the set.
• Cache: keyed by the CodeInstance, looked up in the interpreter's cache first, because inferring again returns a fresh CodeInstance. Redefining a method therefore recompiles what depends on it, which the plan's "invalidation" item required.
• Linking:
  • every set goes into a module of its own, and only the root's entries are external, under process-unique names (jlcodegen_N, shared by all JITs because they share Julia's JIT);
  • the module is checked to be relocatable before linking;
  • literal objects are then bound to their addresses and rooted in the JIT;
  • jl_get_pgcstack_resolved is bound to the runtime's getter (moved from the test JIT into the driver);
  • the pipeline runs, and the module goes into a JITDylib of its own where supported.
• Concurrency: one lock per JIT.

Not included: publishing compiled code into CodeInstances (ci.invoke/specptr), so that native callers use it. That belongs to the hook stack.

Tests (test/jitdriver.jl)

• a differential corpus through jit_call;
• cache hits for the same CodeInstance;
• invalidation: redefining a callee gives a new CodeInstance and new code;
• fallbacks: a stdcall callee is recorded with :fallback and throws with :error;
• varargs callees through the runtime;
• the specsig entry called as a C function (gcstack_arg=false);
• literals surviving a full GC;
• concurrent compilation from 8 threaded tasks (one cache entry).

The JIT tests also pass under JULIACODEGEN_GC_STRESS=1 and with -t 4.

Also: the memory test's allocation count is now the least of three measurements. It failed once in a full nightly run and passed on reruns.

Tested locally with julia +1.12, +1.13 and +nightly: 6955, 6961 and 6960 tests pass.

🤖 Generated with Claude Code