don't initialize non-relocatible globals

Author: vchuravy

src/driver.jl

@@ -256,6 +256,7 @@ const __llvm_initialized = Ref(false)
                     dyn_ir, dyn_meta = codegen(:llvm, CompilerJob(dyn_job; config))
                     dyn_entry_fn = LLVM.name(dyn_meta.entry)
                     merge!(compiled, dyn_meta.compiled)
+                    merge!(gv_to_value, dyn_meta.gv_to_value)
                     @assert context(dyn_ir) == context(ir)
                     link!(ir, dyn_ir)
                     changed = true
@@ -319,6 +320,17 @@ const __llvm_initialized = Ref(false)
         end
     end
 
+    # TODO: Move this to somewhere else?
+    @tracepoint "Resolve relocations eagerly" for gv in globals(ir)
+        name = LLVM.name(gv)
+        init = get(gv_to_value, name, nothing)
+        if init !== nothing
+            @assert initializer(gv) === nothing
+            val = const_inttoptr(ConstantInt(reinterpret(UInt, init)), LLVM.PointerType())
+            initializer!(gv, val)
+        end
+    end
+
     @tracepoint "IR post-processing" begin
         # mark the kernel entry-point functions (optimization may need it)
         if job.config.kernel

src/irgen.jl

@@ -55,6 +55,11 @@ function irgen(@nospecialize(job::CompilerJob))
         new_name = safe_name(old_name)
         if old_name != new_name
             LLVM.name!(val, new_name)
+            val = get(gv_to_value, old_name, nothing)
+            if val !== nothing
+                delete!(gv_to_value, old_name)
+                gv_to_value[new_name] = val
+            end
         end
     end
 
@@ -120,8 +125,6 @@ function irgen(@nospecialize(job::CompilerJob))
         can_throw(job) || lower_throw!(mod)
     end
 
-    # TODO: should we filter out non-preserved_gvs?
-
     return mod, compiled, gv_to_value
 end
 

src/jlgen.jl

@@ -808,11 +808,12 @@ function compile_method_instance(@nospecialize(job::CompilerJob))
         cache_gbl = nothing
     end
 
-    gv_to_value = Dict{String, Any}()
+    gv_to_value = Dict{String, Ptr{Cvoid}}()
 
+    # The caller is responsible for initializing global variables that
+    # point to global values or bindings with their address in memory.
+    # For Julia < v"1.13" to enable relocation we strip out the initializers here.
     if VERSION >= v"1.13.0-DEV.623"
-        # Since Julia 1.13, the caller is responsible for initializing global variables that
-        # point to global values or bindings with their address in memory.
         num_gvars = Ref{Csize_t}(0)
         @ccall jl_get_llvm_gvs(native_code::Ptr{Cvoid}, num_gvars::Ptr{Csize_t},
                            C_NULL::Ptr{Cvoid})::Nothing
@@ -826,12 +827,7 @@ function compile_method_instance(@nospecialize(job::CompilerJob))
 
         for (gv_ref, init) in zip(gvs, inits)
             gv = GlobalVariable(gv_ref)
-            val = const_inttoptr(ConstantInt(Int64(init)), LLVM.PointerType())
-            initializer!(gv, val)
-
-            # TODO: jl_binding_t?
-            @show LLVM.name(gv), val
-            gv_to_value[LLVM.name(gv)] = Base.unsafe_pointer_to_objref(val)
+            gv_to_value[LLVM.name(gv)] = init
         end
     else
         # Prior to this version of Julia we only had access to the values that the global variables
@@ -870,11 +866,15 @@ function compile_method_instance(@nospecialize(job::CompilerJob))
             end
             ptr = reinterpret(Ptr{Cvoid}, convert(UInt, init))
             if ptr in gvalues
-                gv_to_value[LLVM.name(gv)] = Base.unsafe_pointer_to_objref(ptr)
+                gv_to_value[LLVM.name(gv)] = ptr
             end
+            LLVM.initializer!(gv, nothing)
         end
         @assert length(gv_to_value) == length(gvalues)
     end
+    # It's valid to call Base.unsafe_pointer_to_objref on values(gv_to_value),
+    # but we may not be able to "easily" obtain the pointer back later.
+    # (Types, etc, disallow Base.pointer_from_objref on them.)
 
     if VERSION >= v"1.13.0-DEV.1120"
         # on sufficiently recent versions of Julia, we can query the CIs compiled.