Calling `__init__` against a jll directly breaks trim

[BenChung]

When trying to trim & compile

import ZenohC_jll
ZenohC_jll.__init__()
Base.@ccallable function main()::Cint
    println(Core.stdout, "Running")
    return zero(Cint)
end

with the Project.toml

[deps]
ZenohC_jll = "a3bec183-2cd9-52aa-977e-56c7968661ce"

I get an error that

Verifier error #1: unresolved invoke from statement (JLLWrappers.get_julia_libpaths)()::Any
Stacktrace:
 [1] invokelatest_trimmed(::typeof(JLLWrappers.get_julia_libpaths); kwargs::@Kwargs{})
   @ Base ~/.julia/juliaup/julia-1.12.0-beta4+0.x64.linux.gnu/share/julia/juliac-buildscript.jl:45 [inlined]
 [2] macro expansion
   @ ~/.julia/packages/JLLWrappers/GfYNv/src/wrapper_generators.jl:65 [inlined]
 [3] __init__()
   @ ZenohC_jll ~/.julia/packages/ZenohC_jll/4gYxB/src/wrappers/x86_64-linux-gnu.jl:14

Verifier error #2: unresolved call from statement ZenohC_jll.vcat(ZenohC_jll.LIBPATH_list, (JLLWrappers.get_julia_libpaths)()::Any)::Any
Stacktrace:
 [1] macro expansion
   @ ~/.julia/packages/JLLWrappers/GfYNv/src/wrapper_generators.jl:65 [inlined]
 [2] __init__()
   @ ZenohC_jll ~/.julia/packages/ZenohC_jll/4gYxB/src/wrappers/x86_64-linux-gnu.jl:14

Trim verify finished with 2 errors, 0 warnings.
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x1b): undefined reference to `main'
collect2: error: ld returned 1 exit status

(compiling with julia +1.12.0-beta4 --project /home/benchung/.julia/juliaup/julia-1.12.0-beta4+0.x64.linux.gnu/share/julia/juliac.jl --output-exe qfc --experimental --trim=unsafe-warn mwe.jl). It looks like the usage of the JLLWrappers methods isn't inferring correctly. When I add interactiveutils & look at code_typed, I get output that looks like

CodeInfo(
1 ── %1  =    invoke ZenohC_jll.find_artifact_dir()::Any
│            builtin Core.typeassert(%1, ZenohC_jll.String)::String
│    %3  = π (%1, String)
│          nothing::Nothing
│            builtin Base.setglobal!(ZenohC_jll, :artifact_dir, %3)::String
│    %6  = ZenohC_jll.libzenohc_path::Union{Nothing, String}
│    %7  =   builtin (%6 === ZenohC_jll.nothing)::Bool
└───       goto #3 if not %7
2 ── %9  = ZenohC_jll.artifact_dir::String
│    %10 =   builtin Core.tuple(%9, "lib/libzenohc.so")::Tuple{String, String}
│    %11 =    invoke Base.Filesystem.joinpath(%10::Tuple{String, String})::String
│          nothing::Nothing
└───         builtin Base.setglobal!(ZenohC_jll, :libzenohc_path, %11)::String
3 ┄─       nothing::Nothing
│    %15 = ZenohC_jll.libzenohc_path::Union{Nothing, String}
│            builtin Core.typeassert(%15, ZenohC_jll.String)::String
│    %17 = π (%15, String)
│    %18 = $(Expr(:foreigncall, :(:jl_string_ptr), Ptr{Int8}, svec(Any), 0, :(:ccall), :(%17)))::Ptr{Int8}
│    %19 =   builtin (Core.sizeof)(%17)::Int64
│    %20 = intrinsic Core.lshr_int(%19, 63)::Int64
│    %21 = intrinsic Core.trunc_int(Core.UInt8, %20)::UInt8
│    %22 = intrinsic Core.eq_int(%21, 0x01)::Bool
└───       goto #5 if not %22
4 ──          invoke Core.throw_inexacterror(:convert::Symbol, UInt64::Type{T} where T, %19::Int64)::Union{}
└───       unreachable
5 ──       goto #6
6 ── %27 = intrinsic Core.bitcast(Core.UInt64, %19)::UInt64
└───       goto #7
7 ──       goto #8
8 ──       goto #9
9 ──       goto #10
10 ─ %32 = $(Expr(:foreigncall, :(:memchr), Ptr{Int8}, svec(Ptr{Int8}, Int32, UInt64), 0, :(:ccall), :(%18), 0, :(%27), :(%27), 0, :(%18)))::Ptr{Int8}
│    %33 = intrinsic Core.bitcast(Core.UInt, %32)::UInt64
│    %34 =   builtin (0x0000000000000000 === %33)::Bool
│    %35 = intrinsic Base.not_int(%34)::Bool
└───       goto #11
11 ─       goto #13 if not %35
12 ─ %38 =    invoke Base.:(var"#sprint#959")(nothing::Nothing, 0::Int64, sprint::#sprint, show::#show, %17::String)::String
│    %39 =    invoke Base._string("embedded NULs are not allowed in C strings: "::String, %38::Vararg{String})::String
│    %40 = %new(Base.ArgumentError, %39)::ArgumentError
│            builtin Base.throw(%40)::Union{}
└───       unreachable
13 ─ %43 = intrinsic Base.bitcast(Base.Cstring, %18)::Cstring
└───       goto #14
14 ─ %45 = $(Expr(:foreigncall, :(:jl_load_dynamic_library), Ptr{Nothing}, svec(Cstring, UInt32, Int32), 0, :(:ccall), :(%43), 0x00000044, 1, 1, 0x00000044, :(%17)))::Ptr{Nothing}
└───       goto #15
15 ─       goto #16
16 ─       nothing::Nothing
│          nothing::Nothing
│            builtin Base.setglobal!(ZenohC_jll, :libzenohc_handle, %45)::Ptr{Nothing}
│    %51 = ZenohC_jll.libzenohc_path::Union{Nothing, String}
│            builtin Core.typeassert(%51, ZenohC_jll.String)::String
│    %53 = π (%51, String)
│    %54 =    invoke Base.Filesystem._splitdir_nodrive(""::String, %53::String)::Tuple{String, String}
│    %55 = $(Expr(:boundscheck, true))::Bool
│    %56 =   builtin Base.getfield(%54, 1, %55)::String
│    %57 =   builtin Base.getfield(ZenohC_jll.LIBPATH_list, :ref)::GenericMemoryRef{:not_atomic, String, ?}
│    %58 =   builtin Base.getfield(%57, :mem)::GenericMemory{:not_atomic, String, ?}
│    %59 =   builtin Base.getfield(%58, :length)::Int64
│    %60 =   builtin Base.getfield(ZenohC_jll.LIBPATH_list, :size)::Tuple{Int64}
│    %61 = $(Expr(:boundscheck, true))::Bool
│    %62 =   builtin Base.getfield(%60, 1, %61)::Int64
│    %63 = intrinsic Base.add_int(%62, 1)::Int64
│    %64 =   builtin Base.memoryrefoffset(%57)::Int64
│    %65 =   builtin Core.tuple(%63)::Tuple{Int64}
│            builtin Base.setfield!(ZenohC_jll.LIBPATH_list, :size, %65)::Tuple{Int64}
│    %67 = intrinsic Base.add_int(%64, %63)::Int64
│    %68 = intrinsic Base.sub_int(%67, 1)::Int64
│    %69 = intrinsic Base.slt_int(%59, %68)::Bool
└───       goto #18 if not %69
17 ─ %71 = %new(#_growend!##0#_growend!##1{Array{String, 1}, Int64, Int64, Int64, Int64, Int64, GenericMemory{:not_atomic, String, ?}, GenericMemoryRef{:not_atomic, String, ?}}, ZenohC_jll.LIBPATH_list, %68, %64, %63, %62, %59, %58, %57)::#_growend!##0#_growend!##1{Array{String, 1}, Int64, Int64, Int64, Int64, Int64, GenericMemory{:not_atomic, String, ?}, GenericMemoryRef{:not_atomic, String, ?}}
└───          invoke %71()::GenericMemoryRef{:not_atomic, String, ?}
18 ┄       goto #19
19 ─ %74 =   builtin Base.getfield(ZenohC_jll.LIBPATH_list, :size)::Tuple{Int64}
│    %75 = $(Expr(:boundscheck, true))::Bool
│    %76 =   builtin Base.getfield(%74, 1, %75)::Int64
│    %77 =   builtin Base.getfield(ZenohC_jll.LIBPATH_list, :ref)::GenericMemoryRef{:not_atomic, String, ?}
│    %78 =   builtin Base.memoryrefnew(%77, %76, false)::GenericMemoryRef{:not_atomic, String, ?}
│            builtin Base.memoryrefset!(%78, %56, :not_atomic, false)::String
└───       goto #20
20 ─       goto #21
21 ─       nothing::Nothing
│    %83 = ZenohC_jll.libzenohc_path::Union{Nothing, String}
│            builtin Core.typeassert(%83, ZenohC_jll.String)::String
│    %85 = π (%83, String)
│          nothing::Nothing
│            builtin Base.setglobal!(ZenohC_jll, :libzenohc, %85)::String
│             invoke ZenohC_jll.unique!(ZenohC_jll.PATH_list::Array{String, 1})::Any
│             invoke ZenohC_jll.unique!(ZenohC_jll.LIBPATH_list::Array{String, 1})::Any
│    %90 =    invoke Base.:(var"#sprint#959")(nothing::Nothing, 0::Int64, sprint::#sprint, join::#join, ZenohC_jll.PATH_list::Array{String, 1}, ':'::Char)::String
│            builtin Base.setfield!(ZenohC_jll.PATH, :x, %90)::String
│    %92 = dynamic invoke JLLWrappers.get_julia_libpaths()::Any
│    %93 =   dynamic ZenohC_jll.vcat(ZenohC_jll.LIBPATH_list, %92)::Any
│            builtin Core.typeassert(%93, Array{String, 1})::Array{String, 1}
│    %95 = π (%93, Array{String, 1})
│    %96 =    invoke Base.:(var"#sprint#959")(nothing::Nothing, 0::Int64, sprint::#sprint, join::#join, %95::Array{String, 1}, ':'::Char)::String
│            builtin Base.setfield!(ZenohC_jll.LIBPATH, :x, %96)::String
└───       return %96
) => String

Suggesting that the type inferencer isn't descending into the JLLWrappers.get_julia_libpaths call and thus begetting the error.

[giordano]

Related JuliaPackaging/JLLWrappers.jl#55

[JeffBezanson]

Are you saying that if you remove the explicit call to ZenohC_jll.__init__() then it works? init methods of all dependencies are always included, so if one of them is not trimmable I would expect to get these errors whether you call it at load time or not.

[KristofferC]

Jlls have inference disabled so perhaps it is realted to that?

[topolarity]

Are you saying that if you remove the explicit call to ZenohC_jll.init() then it works?

Yeah that's right - it's only an issue if it's called at the top-level

Jlls have inference disabled so perhaps it is realted to that?

Yeah, I think you're exactly right

This probably gets inferred with the standard NativeInterpreter and then the (bad) code in the cache gets re-used without force_enable_inference turned on

julia/Compiler/src/types.jl

Lines 194 to 196 in 3ae69f6

	- `inf_params.force_enable_inference::Bool = false`\\
	If `true`, inference will be performed on functions regardless of whether it was disabled
	at the module level via `Base.Experimental.@compiler_options`.

[JeffBezanson]

Yep that's it; we try to force enable inference when trimming but calling it at the top level prevents that. Oh boy.

Out of curiosity, why do you need this JLL init'd at load time?

[topolarity]

This particular issue is resolved by #58817, and I've opened #58834 for the broader "using non---trim-inferred code in a --trim build" issue