JIT-AOT host binding mode + green test_jit_aot suite [skip ci]

Compile test bodies jit-aware and aot so the emitted objects bind as
SimNode_Jit with run_jit no-op'd. Adds the test_jit_aot harness (macro
co-located under tests/jit_aot), AOT-object glob re-resolution, Func-value
+ cross-module das call/ctor resolution, and interpret-on-miss for anything
unresolved. Brings the test_jit_aot suite to a green 286/286.

Object-emit correctness:
- Optimize and codegen now share one target (use_host_cpu drives both);
  a host-CPU TTI on SVE-capable aarch64 autovectorized to scalable vectors
  (vscale) a generic ISel could not select. Adds --aot-object-generic
  (default true) so a host-specific object is still possible.
- Dispose the MCJIT engine + context on the emit_aot_object early return;
  it skipped finalize_jit and leaked (LeakSanitizer / MCJIT::createJIT).

Author: aleksisch

CMakeLists.txt

@@ -1329,6 +1329,10 @@ if (NOT ${DAS_TESTS_DISABLED})
     endif()
     if(NOT ${DAS_AOT_EXAMPLES_DISABLED} AND NOT (WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 4))
         include(tests/aot/CMakeLists.txt)
+        # JIT-AOT (LLVM-backend .o) mirror of test_aot; LLVM-only, opt-in target.
+        if(NOT ${DAS_LLVM_DISABLED})
+            include(tests/jit_aot/CMakeLists.txt)
+        endif()
     endif()
 endif()
 

include/daScript/simulate/aot_library.h

@@ -38,6 +38,10 @@ namespace das {
     // calls it for is_jit entries.
     DAS_API SimNode * makeAotJitNode ( Context & ctx, void * publ );
 
+    // Run every LLVM-AOT object's recorded glob re-resolution callback for this
+    // Context. Called at the tail of linkCppAot (LLVM-AOT builds only).
+    DAS_API void runLlvmAotGlobInits ( Context & ctx );
+
     // Test standalone context
 
     typedef Context * ( * RegisterTestCreator ) ();

modules/dasLLVM/daslib/llvm_exe.das

@@ -84,13 +84,22 @@ class CollectExternVisitor : AstVisitor {
 
     standalone_ctx : LLVMOpaqueValue?
 
+    // Offline AOT object linked into a host that already has the runtime: only
+    // re-resolve builtin-accessor globals (into `builder`); register NO modules
+    // or functions (the host owns those). See emit_aot_object_globinit.
+    aot_object : bool
+    // The globinit ctor's Context* parameter (set by emit_aot_object_globinit),
+    // used to resolve Func-value globs to the host's SimFunction* at load.
+    aot_ctx_arg : LLVMOpaqueValue?
+
 
     def CollectExternVisitor(standalone_context : LLVMOpaqueValue?; _ctx : LLVMContextRef;
                              _builder : LLVMBuilderRef,
                              _mod : LLVMOpaqueModule?; var _types : PrimitiveTypes?,
-                             uids : UidNodes?; register_all : bool) {
+                             uids : UidNodes?; register_all : bool; aot_obj : bool = false) {
         any_unimplemented = false
         needs_whole_lib = false
+        aot_object = aot_obj
         uid := uids
         ctx = _ctx
         standalone_ctx = standalone_context
@@ -99,6 +108,11 @@ class CollectExternVisitor : AstVisitor {
         builder = _builder
         register_mod_type = LLVMFunctionType(types.LLVMVoidPtrType(), array<LLVMTypeRef>())
 
+        if (aot_object) {
+            // Glob re-resolution goes into the caller-provided ctor (builder);
+            // no initialize_modules(), no env, no module registration.
+            init_builder = _builder
+        } else {
         // Create initialize_modules() function — filled incrementally as we discover needed modules
         let init_fn_type = LLVMFunctionType(types.t_void, array<LLVMTypeRef>())
         init_fn = LLVMGetNamedFunction(g_mod, "initialize_modules")
@@ -146,6 +160,7 @@ class CollectExternVisitor : AstVisitor {
             }
             registered_modules["strings"] = true
         }
+        }
 
         // void * get_jit_table_{at,find,erase} ( int32_t baseType, Context * context, LineInfoArg * at )
         reg_extern_tab_type = LLVMFunctionType(types.LLVMVoidPtrType(),
@@ -225,6 +240,21 @@ class CollectExternVisitor : AstVisitor {
     }
 
     def register_function(fn : Function?) : LLVMOpaqueValue? {
+        // AOT-into-host: a Func VALUE must be the host Context's SimFunction* (Func
+        // dispatch goes through SimFunction, not native code). The function is
+        // already bound in the host by linkCppAot, so look it up by mangled-name
+        // hash against the ctor's Context* arg -- works for builtins too (which have
+        // no publ symbol in this object). No standalone-context registration.
+        if (aot_object) {
+            let gfType = LLVMFunctionType(types.LLVMVoidPtrType(),
+                fixed_array<LLVMTypeRef>(types.t_int64, types.LLVMVoidPtrType()))
+            var gfFn = LLVMGetNamedFunction(g_mod, "das_aot_get_func_by_mnh")
+            if (gfFn == null) {
+                gfFn = LLVMAddFunctionWithType(g_mod, "das_aot_get_func_by_mnh", gfType)
+            }
+            var gf_args = array<LLVMValueRef>(types.ConstI64(fn.getMangledNameHash), aot_ctx_arg)
+            return LLVMBuildCall2(builder, gfType, gfFn, gf_args, "")
+        }
         let fnmna = uid.get_dll_fn_name_ptr(fn)
         let fn_publ = LLVMGetNamedFunction(g_mod, fnmna.publ())
         if (fn_publ == null) return null
@@ -266,6 +296,7 @@ class CollectExternVisitor : AstVisitor {
     }
 
     def ensure_module(m : Module?) {
+        if (aot_object) return  // host already has every module registered
         if (m == null) return
         let mod_name = string(m.name)
         // Dynamic (.shared_module) modules are normally registered via the
@@ -576,6 +607,64 @@ class CollectExternVisitor : AstVisitor {
     }
 }
 
+// Build a load ctor/dtor pair that re-resolves this AOT object's builtin-accessor
+// globals to the HOST's real helpers. Offline objects leave those globals null +
+// internal (save_address_global / get_or_create_table_fn under emit_aot_object),
+// because the codegen-process addresses are meaningless in the host; this ctor
+// fills them at load via linker-resolved accessors (get_jit_table_at, das_get_jit_new,
+// jit_initialize_extern_function, ...) and points ExprAddr globals at their publ
+// symbols. No module/function registration -- the host owns those; functions bind
+// through Program::linkCppAot. Returns the (ctor, dtor) for llvm.global_ctors/dtors.
+def public emit_aot_object_globinit(ctx : LLVMContextRef; mod : LLVMOpaqueModule?;
+                                    var types : PrimitiveTypes?; var funcs : array<FunctionPtr>;
+                                    var uids : UidNodes?) : LLVMOpaqueValue? {
+    // void das_aot_object_globinit_constructor(Context* ctx): ctx is used to
+    // resolve Func-value globs to the host's SimFunction* (das_aot_get_func_by_mnh).
+    let fnType = LLVMFunctionType(types.t_void, fixed_array<LLVMTypeRef>(types.LLVMVoidPtrType()))
+    let ctor = LLVMAddFunctionWithType(g_mod, "das_aot_object_globinit_constructor", fnType)
+    LLVMSetLinkage(ctor, LLVMLinkage.LLVMPrivateLinkage)
+    var b = LLVMCreateBuilderInContext(ctx)
+    LLVMPositionBuilderAtEnd(b, LLVMAppendBasicBlockInContext(ctx, ctor, "entry"))
+    // The visitor aliases the caller's uids (its `uid` field). We deliberately do
+    // NOT delete it: deleting cascades into that shared uid, and the caller keeps
+    // using uids afterward (the das_aot_register loop). It is a gc_node, reclaimed
+    // by the surrounding ast_gc_guard / process teardown.
+    var extern_resolver = new CollectExternVisitor(null, ctx, b, mod, types, uids, false, true)
+    extern_resolver.aot_ctx_arg = LLVMGetParam(ctor, 0u)
+    make_visitor(*extern_resolver) $(adapter_resolve) {
+        ast_gc_guard() {
+            for (fn in funcs) {
+                visit(fn, adapter_resolve)
+            }
+        }
+    }
+    // Fill the cross-module call/ctor target globs recorded during codegen with the
+    // host Context's SimFunction* for each callee (by mangled-name hash).
+    if (!(g_aot_func_globs |> empty())) {
+        let gfType = LLVMFunctionType(types.LLVMVoidPtrType(),
+            fixed_array<LLVMTypeRef>(types.t_int64, types.LLVMVoidPtrType()))
+        var gfFn = LLVMGetNamedFunction(g_mod, "das_aot_get_func_by_mnh")
+        if (gfFn == null) {
+            gfFn = LLVMAddFunctionWithType(g_mod, "das_aot_get_func_by_mnh", gfType)
+        }
+        let ctx_arg = LLVMGetParam(ctor, 0u)
+        for (fg in g_aot_func_globs) {
+            if (fg.glob == null) {
+                continue
+            }
+            var gf_args = array<LLVMValueRef>(types.ConstI64(fg.mnh), ctx_arg)
+            var simfn = LLVMBuildCall2(b, gfType, gfFn, gf_args, "")
+            // The glob is a pointer-to-fn-type; the SimFunction* (void*) bitcasts in.
+            let elemT = LLVMGlobalGetValueType(fg.glob)
+            var casted = LLVMBuildPointerCast(b, simfn, elemT, "")
+            LLVMBuildStore(b, casted, fg.glob)
+        }
+    }
+    LLVMBuildRetVoid(b)
+    LLVMDisposeBuilder(b)
+    return ctor
+}
+
 def collect_external_functions(standalone_context : LLVMOpaqueValue?; ctx : LLVMContextRef; builder : LLVMBuilderRef,
                                mod : LLVMOpaqueModule?; var types : PrimitiveTypes?;
                                var funcs : array<FunctionPtr>; var uids : UidNodes?;

modules/dasLLVM/daslib/llvm_jit.das

@@ -218,6 +218,10 @@ bitfield public LlvmJitFlags {
     gen_exe,
     // Is debug info needed. Debug info not fully supported and not tested yet.
     need_di,
+    // Offline AOT object linked into a host that already has the runtime. Like gen_exe,
+    // codegen-process addresses are meaningless, so builtin-accessor globals are emitted
+    // internal + null and re-resolved by a load ctor (host owns the modules/functions).
+    emit_aot_object,
 }
 
 // Non-string workhorse key types that get the inline open-addressed find/at (build_workhorse_*):
@@ -1512,32 +1516,35 @@ class public LlvmJitVisitor : AstVisitor {
         var global_addr = LLVMGetNamedGlobal(g_mod, name.glob())
         if (global_addr == null) {
             global_addr = LLVMAddGlobal(g_mod, nonnull_type, name.glob())
-            if (flags.gen_exe) {
+            if (flags.gen_exe || flags.emit_aot_object) {
                 // nolint:STYLE014
-                // For standalone exes the JIT-process address is meaningless
-                // (different ASLR slide in the new process). Leave the global
-                // null at link time; the runtime initialize_modules() walks
-                // every used builtin and overwrites this slot via
-                // jit_initialize_extern_function. Baking the codegen-time
-                // address as a constant initializer would let LLVM
-                // constant-fold loads — observed at top-level `let` initializers
-                // — to the JIT-process immediate, which the standalone exe then
-                // calls and crashes on (dyld loaded the dylib elsewhere).
+                // The JIT-process address is meaningless in the host (different ASLR slide),
+                // and baking it as a const initializer lets LLVM constant-fold loads to that
+                // dead immediate. Leave null + private; a load-time init (initialize_modules
+                // for exe, the globinit ctor for the object) fills it via the runtime accessor.
                 set_private_linkage(global_addr)
                 LLVMSetInitializer(global_addr, LLVMConstPointerNull(nonnull_type))
             } else {
                 set_public_linkage(global_addr)
                 LLVMSetInitializer(global_addr, types.ConstPtr(address |> intptr, nonnull_type))
             }
-        } elif (!flags.gen_exe) {
-            // JIT mode codegen's each function once, so a duplicate name is a real bug. Exe mode
-            // re-codegens the same global-var initializers in init_globals + init_globals_clone, so the
-            // same slot is legitimately re-encountered — reuse silently (idempotent: same name, same slot).
+        } elif (!(flags.gen_exe || flags.emit_aot_object)) {
+            // JIT codegens each function once, so a duplicate is a real bug (exe/object modes
+            // legitimately re-encounter a slot via init_globals + init_globals_clone).
             failed("Name duplicate {name.glob()}\n")
         }
         return load_local_const(global_addr, nonnull_type)
     }
 
+    // emit-object mode: record a cross-module call/ctor target glob (just created
+    // null by save_address_global) so emit_aot_object_globinit fills it with the
+    // host Context's SimFunction* (das_aot_get_func_by_mnh) at load.
+    def aot_record_func_glob(name : DllName; func : Function?) {
+        if (g_emit_aot_object_globals) {
+            g_aot_func_globs |> push((glob = LLVMGetNamedGlobal(g_mod, name.glob()), mnh = func.getMangledNameHash))
+        }
+    }
+
     def set_meta_cconv(instr : LLVMOpaqueValue?; conv : string) {
         var values : LLVMOpaqueValue? [1]
         values[0] = LLVMMDStringInContext(g_ctx, conv, uint(length(conv)))
@@ -1712,6 +1719,7 @@ class public LlvmJitVisitor : AstVisitor {
                 if (glob_fn_ptr == null) {
                     var MNH_ADDR = get_function_addr(jit_context, expr.func)
                     glob_fn_ptr = save_address_global(uid.get_dll_fn_name_ptr(expr.func), MNH_ADDR)
+                    aot_record_func_glob(uid.get_dll_fn_name_ptr(expr.func), expr.func)
                 }
                 var params : array<LLVMOpaqueValue?>  // nolint:STYLE012 — conditional cmresEval push between fixed args
                 params |> push(glob_fn_ptr)  // mnh
@@ -4252,6 +4260,7 @@ class public LlvmJitVisitor : AstVisitor {
             if (ctor == null) {
                 var MNH_ADDR = get_function_addr(jit_context, expr_func)
                 ctor = save_address_global(name, MNH_ADDR)
+                aot_record_func_glob(name, expr_func)
             }
             var params <- [
                 ctor,  // mnh
@@ -7915,16 +7924,11 @@ def public generate_llvm_code(var dll : DLLHandle?; fmna : DllName; dll_enabled
     return code
 }
 
-// Creates a single global constructor (run at compiled-object startup) for complex global types
-// like fileInfo that can't be const-initialized.
+// Emit the module's load/unload ctors into llvm.global_ctors/dtors: the FileInfo ctor/dtor,
+// plus -- in offline AOT object mode (emit_aot) -- a ctor calling das_aot_register per function
+// so the .o self-registers into the AOT library at load. funcs/uids/prog read only when emit_aot.
 [macro_function]
-// Emit the module's load/unload constructors into llvm.global_ctors/dtors: the
-// FileInfo ctor/dtor, plus -- in offline AOT object mode (emit_aot) -- a ctor
-// that calls the linker-resolved extern das_aot_register(aotHash, publ) for each
-// of this module's functions, so the emitted .o self-registers into the AOT
-// library at load (reusing the existing AotFactory / linkCppAot path via
-// SimNode_Jit). funcs/uids/prog are only read when emit_aot is true.
-def public generate_global_ctors_dtors(types : PrimitiveTypes?; jit_mode : bool; emit_aot : bool; funcs : array<FunctionPtr>; var uids : UidNodes?; prog : Program?) {
+def public generate_global_ctors_dtors(types : PrimitiveTypes?; jit_mode : bool; emit_aot : bool; funcs : array<FunctionPtr>; var uids : UidNodes?; prog : Program?; glob_ctor : LLVMOpaqueValue? = null) {
     var ctor_dtor <- [
         // FileInfo
         generate_fileinfo_ctor_dtor(*types, active_filenames, jit_mode)
@@ -7938,8 +7942,7 @@ def public generate_global_ctors_dtors(types : PrimitiveTypes?; jit_mode : bool;
             regFn = LLVMAddFunctionWithType(g_mod, "das_aot_register", regType)
         }
         let functionType = LLVMFunctionType(types.t_void, null, 0u, 0)
-        // Private: referenced only via llvm.global_ctors, and each object defines it,
-        // so public linkage would clash when many objects link into one host.
+        // Private: each object defines it, so public linkage would clash when many link together.
         let reg_ctor = LLVMAddFunctionWithType(g_mod, "das_aot_register_constructor", functionType)
         let reg_dtor = LLVMAddFunctionWithType(g_mod, "das_aot_register_destructor", functionType)
         set_private_linkage(reg_ctor)
@@ -7961,6 +7964,19 @@ def public generate_global_ctors_dtors(types : PrimitiveTypes?; jit_mode : bool;
             var reg_args = array<LLVMValueRef>(types.ConstI64(aot_hash), publ_ptr)
             LLVMBuildCall2(ctor_builder, regType, regFn, reg_args, "")
         }
+        // Record this object's glob re-resolution callback; the runtime runs it lazily at
+        // the first AotLibrary drain (NOT here at static-init, where its accessors would
+        // fault on a null bound environment).
+        if (glob_ctor != null) {
+            let giType = LLVMFunctionType(types.t_void, fixed_array<LLVMTypeRef>(types.LLVMVoidPtrType()))
+            var giFn = LLVMGetNamedFunction(g_mod, "das_aot_register_globinit")
+            if (giFn == null) {
+                giFn = LLVMAddFunctionWithType(g_mod, "das_aot_register_globinit", giType)
+            }
+            var gi_ptr = LLVMBuildPointerCast(ctor_builder, glob_ctor, types.LLVMVoidPtrType(), "")
+            var gi_args = array<LLVMValueRef>(gi_ptr)
+            LLVMBuildCall2(ctor_builder, giType, giFn, gi_args, "")
+        }
         LLVMBuildRetVoid(ctor_builder)
         LLVMBuildRetVoid(dtor_builder)
         LLVMDisposeBuilder(ctor_builder)

modules/dasLLVM/daslib/llvm_jit_cli.das

@@ -69,4 +69,8 @@ struct public JitCliOptions {
     @clarg_name = "jit-register-all-modules"
     @clarg_doc = "JIT (-exe only): register all builtin native modules (math, fio, dasbind, ...) at exe startup, so a standalone compiler-driver exe can recompile arbitrary daslang at runtime"
     register_all_modules : Option<bool>
+
+    @clarg_name = "aot-object-generic"
+    @clarg_doc = "JIT (--aot-object): emit a portable generic-CPU object (default true). Pass =false for a host-CPU-specific object (host features, e.g. SVE/AVX) that only runs on matching hardware. Optimize + codegen use the same target either way."
+    aot_object_generic : Option<bool>
 }

modules/dasLLVM/daslib/llvm_jit_common.das

@@ -253,8 +253,14 @@ def private get_or_create_table_fn(llvm_module : LLVMOpaqueModule?; var types :
 
         let at_ptr_type = LLVMPointerType(at_type, 0u)
         tab_fun = LLVMAddGlobal(llvm_module, LLVMPointerType(at_ptr_type, 0u), fn_name.glob())
-        add_table_linkage(tab_fun)
-        LLVMSetInitializer(tab_fun, types.ConstPtr(fn_ptr |> intptr(), at_ptr_type))
+        if (g_emit_aot_object_globals) {
+            // Per-object internal + null; the globinit ctor re-resolves it at load.
+            LLVMSetLinkage(tab_fun, LLVMLinkage.LLVMInternalLinkage)
+            LLVMSetInitializer(tab_fun, LLVMConstPointerNull(LLVMPointerType(at_ptr_type, 0u)))
+        } else {
+            add_table_linkage(tab_fun)
+            LLVMSetInitializer(tab_fun, types.ConstPtr(fn_ptr |> intptr(), at_ptr_type))
+        }
     } else {
         // we already created it
         tab_fun = LLVMGetNamedGlobal(llvm_module, fn_name.glob())
@@ -536,6 +542,16 @@ def public LLVMAddFunctionWithType(mod : LLVMModuleRef; name : string; typ : LLV
 
 var g_jit_clopts_parsed = false
 
+// Set while emitting an offline AOT object: builtin-accessor globals are emitted
+// internal + null and re-resolved by the emit_aot_object_globinit load ctor,
+// instead of a baked codegen-process address. run_jit sets/clears it around codegen.
+var public g_emit_aot_object_globals = false
+
+// Emit-object mode: cross-module / non-jit das call + ctor target globs hold a host-
+// meaningless SimFunction*. Recorded here (glob + callee mnh) during codegen; the
+// globinit ctor fills them from the host Context at load. run_jit clears per compile.
+var public g_aot_func_globs : array<tuple<glob : LLVMOpaqueValue?; mnh : uint64>>
+
 // LLVM's unroll / partial-unroll / unroll-and-jam cost-model thresholds are compiled-in cl::opt
 // globals; daslang's JIT path never runs cl::ParseCommandLineOptions, so without these the O3
 // pipeline lands different (worse) IR shapes than `opt` on the same input (bisected on dasProfile).
@@ -1167,12 +1183,10 @@ def public with_default_target_machine(opt_level : uint; use_host_cpu : bool;
     }
 }
 
-// Offline AOT: emit a native object only, no linker step. Used by the
-// jit_emit_object path that produces .o objects statically linked into a host
-// binary. Generic CPU (use_host_cpu=false) so the object runs on any machine the
-// host targets.
-def public emit_object_only(mod : LLVMOpaqueModule?; out_path : string) {
-    with_default_target_machine(3u, false) $(targetMachine : LLVMTargetMachineRef) {
+// Offline AOT: emit a native object only, no linker step (jit_emit_object path).
+// use_host_cpu=false (default) targets a generic CPU so the .o is portable; true bakes host features.
+def public emit_object_only(mod : LLVMOpaqueModule?; out_path : string; use_host_cpu : bool = false) {
+    with_default_target_machine(3u, use_host_cpu) $(targetMachine : LLVMTargetMachineRef) {
         let error : string?
         let file = add_obj_extension(out_path)
         let filetype = LLVMCodeGenFileType.LLVMObjectFile