Use jl_parse_opts for jl_options shim instead of manual struct assignment

Instead of generating C code that manually assigns jl_options struct
fields, call jl_parse_opts with a synthetic argv. This reuses Julia's
own option parsing logic and avoids duplicating the parsing for threads,
handle-signals, etc.

The constructor saves/restores getopt global state and image_file to
avoid interfering with the host process. Options are validated at
compile time by running a Julia subprocess with the same flags.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gbaraldi

src/compiling.jl

@@ -61,9 +61,9 @@ function compile_products(recipe::ImageRecipe)
         recipe.add_ccallables = true
     end
     # Default: disable signal handlers and limit to single thread for shared libraries
-    if recipe.output_type == "--output-lib" && isempty(recipe.jl_options)
-        recipe.jl_options["handle-signals"] = "no"
-        recipe.jl_options["threads"] = "1"
+    if recipe.output_type == "--output-lib"
+        get!(recipe.jl_options, "handle-signals", "no")
+        get!(recipe.jl_options, "threads", "1")
     end
     if recipe.cpu_target === nothing
         recipe.cpu_target = get(ENV,"JULIA_CPU_TARGET", nothing)
@@ -214,79 +214,16 @@ function _validate_jl_options(jl_options::Dict{String,String})
 end
 
 """
-Parse `--jl-option handle-signals=yes|no` into C assignments.
-Mirrors Julia's `--handle-signals` parsing in `jloptions.c`.
-"""
-function _emit_handle_signals(io::IO, value::String)
-    if value == "yes"
-        println(io, "opts->handle_signals = JL_OPTIONS_HANDLE_SIGNALS_ON;")
-    elseif value == "no"
-        println(io, "opts->handle_signals = JL_OPTIONS_HANDLE_SIGNALS_OFF;")
-    else
-        error("Invalid value for handle-signals: \"$value\". Expected \"yes\" or \"no\".")
-    end
-end
-
-"""
-Parse `--jl-option threads=N[,M]` into C assignments.
-Mirrors Julia's `--threads` / `-t` parsing in `jloptions.c`:
-- `N` → N threads in default pool; if N==1, 1 pool; else 2 pools (+ 1 interactive)
-- `N,M` → N default + M interactive; if M==0, 1 pool; else 2 pools
-- `N,auto` → N default + 1 interactive, 2 pools
-
-Does not support `auto` for N (libraries should specify a concrete thread count).
-"""
-function _emit_threads(io::IO, value::String)
-    parts = split(value, ','; limit=2)
-    nthreads_str = parts[1]
-    nthreads_str == "auto" && error("\"auto\" is not supported for threads in --jl-option; specify a concrete count.")
-    nthreads = tryparse(Int, nthreads_str)
-    nthreads === nothing && error("Invalid thread count: \"$nthreads_str\"")
-    nthreads < 1 && error("Thread count must be >= 1, got $nthreads")
-
-    if length(parts) == 2
-        # N,M or N,auto
-        ipart = parts[2]
-        if ipart == "auto"
-            nthreadsi = 1
-        else
-            nthreadsi = tryparse(Int, ipart)
-            nthreadsi === nothing && error("Invalid interactive thread count: \"$ipart\"")
-            nthreadsi < 0 && error("Interactive thread count must be >= 0, got $nthreadsi")
-        end
-    elseif nthreads == 1
-        # Like Julia: 1 thread → no interactive pool
-        nthreadsi = 0
-    else
-        # Like Julia: N>1 → add 1 interactive thread
-        nthreadsi = 1
-    end
-
-    nthreadpools = nthreadsi == 0 ? 1 : 2
-    total = nthreads + nthreadsi
-
-    println(io, "opts->nthreads = $total;")
-    println(io, "opts->nthreadpools = $nthreadpools;")
-    println(io, "{")
-    println(io, "    int16_t *ntpp = (int16_t *)malloc($nthreadpools * sizeof(int16_t));")
-    println(io, "    if (ntpp) {")
-    println(io, "        ntpp[0] = (int16_t)$nthreads;")
-    if nthreadpools == 2
-        println(io, "        ntpp[1] = (int16_t)$nthreadsi;")
-    end
-    println(io, "        opts->nthreads_per_pool = ntpp;")
-    println(io, "    }")
-    println(io, "}")
-end
-
-"""
-Generate and compile a C shim that overrides `jl_options` fields via an
-`__attribute__((constructor))`.
+Generate and compile a C shim that calls `jl_parse_opts` with a synthetic
+argv in an `__attribute__((constructor))`.
 
 The boilerplate C code lives in `scripts/juliac-jl-options-shim.c` and
-`#include`s a generated `juliac-jl-options-body.h` containing just the
-option assignments.  See the shim source for how `jl_options` is resolved
-on each platform.
+`#include`s a generated `juliac-jl-options-body.h` containing the argv
+string literals.
+
+After compilation, links the shim into a trivial executable and runs it
+to validate that `jl_parse_opts` accepts the options. This catches invalid
+values at compile time rather than at load time.
 
 Returns the path to the compiled object file.
 """
@@ -297,14 +234,11 @@ function _compile_jl_options_shim(jl_options::Dict{String,String}; verbose::Bool
     shim_src = joinpath(JuliaC.SCRIPTS_DIR, "juliac-jl-options-shim.c")
     body_hdr = joinpath(tmpdir, "juliac-jl-options-body.h")
     init_obj = joinpath(tmpdir, "juliac-jl-options-init.o")
-    # Generate only the option-assignment body
+    # Generate argv entries for jl_parse_opts
     open(body_hdr, "w") do io
-        println(io, "/* Generated by JuliaC — jl_options field assignments */")
-        if haskey(jl_options, "handle-signals")
-            _emit_handle_signals(io, jl_options["handle-signals"])
-        end
-        if haskey(jl_options, "threads")
-            _emit_threads(io, jl_options["threads"])
+        println(io, "/* Generated by JuliaC — jl_parse_opts argv entries */")
+        for (key, value) in jl_options
+            println(io, "\"--$(key)=$(value)\",")
         end
     end
     verbose && println("Generated jl_options body: $body_hdr")
@@ -320,5 +254,16 @@ function _compile_jl_options_shim(jl_options::Dict{String,String}; verbose::Bool
     catch e
         error("jl_options init shim compilation failed: ", e)
     end
+    # Validate by running julia with the same flags.
+    julia_bin = joinpath(Sys.BINDIR, "julia")
+    validate_cmd = `$julia_bin`
+    for (key, value) in jl_options
+        validate_cmd = `$validate_cmd --$(key)=$(value)`
+    end
+    validate_cmd = `$validate_cmd -e ""`
+    verbose && println("Validating jl_options: $validate_cmd")
+    if !success(pipeline(validate_cmd; stdout=devnull, stderr))
+        error("Invalid --jl-option values. Check that option values match Julia CLI syntax (e.g. --handle-signals=yes|no, --threads=N[,M]).")
+    end
     return init_obj
 end

src/scripts/juliac-jl-options-shim.c

@@ -3,50 +3,49 @@
  *
  * Sets jl_options fields before jl_init via __attribute__((constructor)).
  *
- * On macOS, dlsym with a handle from dlopen searches that image and its
- * dependencies, so we use dladdr/dlopen/dlsym to resolve jl_options from
- * our own libjulia dependency.
+ * Calls jl_parse_opts with a synthetic argv to reuse Julia's own option
+ * parsing logic. Saves and restores getopt global state and image_file
+ * to avoid interfering with the host process.
  *
- * On Linux, dlopen(RTLD_NOLOAD) on the main executable returns NULL, so
- * we use RTLD_DEFAULT which searches all loaded shared objects. This is
- * safe because our libjulia is the only one loaded at constructor time.
- *
- * On Windows, DLL import resolution is per-module, so &jl_options already
- * resolves to the correct instance from our libjulia dependency.
- *
- * The actual option assignments are generated by JuliaC and included via
+ * The argv entries are generated by JuliaC and included via
  * "juliac-jl-options-body.h".
  */
 
-#define _GNU_SOURCE
-
 #include <julia.h>
 #include <stdlib.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
+#include <getopt.h>
 
 __attribute__((constructor))
 static void juliac_set_jl_options(void) {
-#ifdef _WIN32
-    jl_options_t *opts = &jl_options;
-#elif defined(__APPLE__)
-    Dl_info info;
-    if (!dladdr((void *)&juliac_set_jl_options, &info)) return;
-    void *self = dlopen(info.dli_fname, RTLD_NOLOAD | RTLD_NOW);
-    if (!self) return;
-    jl_options_t *opts = (jl_options_t *)dlsym(self, "jl_options");
-    dlclose(self);
-    if (!opts) return;
-#else
-    /* Linux: RTLD_DEFAULT searches all loaded shared objects */
-    jl_options_t *opts = (jl_options_t *)dlsym(RTLD_DEFAULT, "jl_options");
-    if (!opts) return;
-#endif
-
-    /* Generated option assignments */
+    /* Save getopt global state */
+    int saved_optind = optind;
+    int saved_opterr = opterr;
+    int saved_optopt = optopt;
+    char *saved_optarg = optarg;
+
+    /* Save fields that jl_parse_opts unconditionally overwrites */
+    const char *saved_image_file = jl_options.image_file;
+
+    /* Synthetic argv with generated options */
+    char *argv[] = {
+        "juliac",
 #include "juliac-jl-options-body.h"
+        NULL
+    };
+    int argc = (int)(sizeof(argv) / sizeof(argv[0])) - 1; /* exclude NULL */
+    char **argvp = argv;
+
+    /* Reset getopt so it parses our argv from the beginning */
+    optind = 0;
+
+    jl_parse_opts(&argc, &argvp);
+
+    /* Restore overwritten fields */
+    jl_options.image_file = saved_image_file;
+
+    /* Restore getopt global state */
+    optind = saved_optind;
+    opterr = saved_opterr;
+    optopt = saved_optopt;
+    optarg = saved_optarg;
 }

test/programatic.jl

@@ -338,7 +338,7 @@ end
     @test img.jl_options["handle-signals"] == "no"
     @test img.jl_options["threads"] == "1"
 
-    # User-provided jl_options should not be overwritten
+    # User-provided jl_options should not be overwritten, other defaults still applied
     img2 = JuliaC.ImageRecipe(
         file = TEST_LIB_SRC,
         output_type = "--output-lib",
@@ -349,7 +349,7 @@ end
     )
     JuliaC.compile_products(img2)
     @test img2.jl_options["handle-signals"] == "yes"
-    @test !haskey(img2.jl_options, "threads")
+    @test img2.jl_options["threads"] == "1"  # default still applied
 
     # --output-exe should not auto-populate jl_options
     img3 = JuliaC.ImageRecipe(
@@ -380,14 +380,6 @@ end
     # Supported options should pass validation
     JuliaC._validate_jl_options(Dict("handle-signals" => "no"))
     JuliaC._validate_jl_options(Dict("threads" => "1"))
-
-    # Invalid handle-signals value should error
-    @test_throws ErrorException JuliaC._emit_handle_signals(devnull, "maybe")
-
-    # Invalid threads value should error
-    @test_throws ErrorException JuliaC._emit_threads(devnull, "auto")
-    @test_throws ErrorException JuliaC._emit_threads(devnull, "0")
-    @test_throws ErrorException JuliaC._emit_threads(devnull, "abc")
 end
 
 @testset "jl_options applied at runtime" begin