Update CodeInfo struct and handling

Set has_image_globalref in linearization

Co-authored-by: Claire Foster <[email protected]>

Author: mlechu

src/eval.jl

@@ -20,19 +20,29 @@ if VERSION < _CodeInfo_need_ver
 else
     # debuginfo changed completely as of https://github.com/JuliaLang/julia/pull/52415
     # nargs / isva was added as of       https://github.com/JuliaLang/julia/pull/54341
+    # field rettype added in             https://github.com/JuliaLang/julia/pull/54655
+    # field has_image_globalref added in https://github.com/JuliaLang/julia/pull/57433
     # CodeInfo constructor. TODO: Should be in Core
     let
         fns = fieldnames(Core.CodeInfo)
         fts = fieldtypes(Core.CodeInfo)
         conversions = [:(convert($t, $n)) for (t,n) in zip(fts, fns)]
 
-        expected_fns = (:code, :debuginfo, :ssavaluetypes, :ssaflags, :slotnames, :slotflags, :slottypes, :parent, :method_for_inference_limit_heuristics, :edges, :min_world, :max_world, :nargs, :propagate_inbounds, :has_fcall, :nospecializeinfer, :isva, :inlining, :constprop, :purity, :inlining_cost)
-        expected_fts = (Vector{Any}, Core.DebugInfo, Any, Vector{UInt32}, Vector{Symbol}, Vector{UInt8}, Any, Any, Any, Any, UInt64, UInt64, UInt64, Bool, Bool, Bool, Bool, UInt8, UInt8, UInt16, UInt16)
+        expected_fns = (:code, :debuginfo, :ssavaluetypes, :ssaflags, :slotnames, :slotflags, :slottypes, :rettype, :parent, :edges, :min_world, :max_world, :method_for_inference_limit_heuristics, :nargs, :propagate_inbounds, :has_fcall, :has_image_globalref, :nospecializeinfer, :isva, :inlining, :constprop, :purity, :inlining_cost)
+        expected_fts = (Vector{Any}, Core.DebugInfo, Any, Vector{UInt32}, Vector{Symbol}, Vector{UInt8}, Any, Any, Any, Any, UInt64, UInt64, Any, UInt64, Bool, Bool, Bool, Bool, Bool, UInt8, UInt8, UInt16, UInt16)
 
-        code = if fns != expected_fns || fts != expected_fts
+        code = if fns != expected_fns
+            unexpected_fns = collect(setdiff(Set(fns), Set(expected_fns)))
+            missing_fns = collect(setdiff(Set(expected_fns), Set(fns)))
             :(function _CodeInfo(args...)
-                error("Unrecognized CodeInfo layout: Maybe version $VERSION is to new for this version of JuliaLowering?")
-            end)
+                  error("Unrecognized CodeInfo fields: Maybe version $VERSION is too new for this version of JuliaLowering?"
+                         * isempty(unexpected_fns) ? "" : "\nUnexpected fields found: $($unexpected_fns)"
+                         * isempty(missing_fns)    ? "" : "\nMissing fields:          $($missing_fns)")
+              end)
+        elseif fts != expected_fts
+            :(function _CodeInfo(args...)
+                  error("Unrecognized CodeInfo field types: Maybe version $VERSION is too new for this version of JuliaLowering?")
+              end)
         else
             :(function _CodeInfo($(fns...))
                 $(Expr(:new, :(Core.CodeInfo), conversions...))
@@ -142,6 +152,8 @@ function to_code_info(ex, mod, funcname, slots)
 
     debuginfo = finish_ir_debug_info!(current_codelocs_stack)
 
+    has_image_globalref = false
+
     # TODO: Set ssaflags based on call site annotations:
     # - @inbounds annotations
     # - call site @inline / @noinline
@@ -172,6 +184,7 @@ function to_code_info(ex, mod, funcname, slots)
     max_world           = typemax(Csize_t)
     isva                = false
     inlining_cost       = 0xffff
+    rettype             = Any
 
     _CodeInfo(
         stmts,
@@ -181,14 +194,16 @@ function to_code_info(ex, mod, funcname, slots)
         slotnames,
         slotflags,
         slottypes,
+        rettype,
         parent,
-        method_for_inference_limit_heuristics,
         edges,
         min_world,
         max_world,
+        method_for_inference_limit_heuristics,
         nargs,
         propagate_inbounds,
         has_fcall,
+        has_image_globalref,
         nospecializeinfer,
         isva,
         inlining,

src/linear_ir.jl

@@ -69,14 +69,15 @@ end
 Context for creating linear IR.
 
 One of these is created per lambda expression to flatten the body down to
-a sequence of statements (linear IR).
+a sequence of statements (linear IR), which eventually becomes one CodeInfo.
 """
 struct LinearIRContext{GraphType} <: AbstractLoweringContext
     graph::GraphType
     code::SyntaxList{GraphType, Vector{NodeId}}
     bindings::Bindings
     next_label_id::Ref{Int}
     is_toplevel_thunk::Bool
+    has_image_globalref::Ref{Bool}
     lambda_bindings::LambdaBindings
     return_type::Union{Nothing, SyntaxTree{GraphType}}
     break_targets::Dict{String, JumpTarget{GraphType}}
@@ -92,8 +93,9 @@ function LinearIRContext(ctx, is_toplevel_thunk, lambda_bindings, return_type)
     graph = syntax_graph(ctx)
     rett = isnothing(return_type) ? nothing : reparent(graph, return_type)
     GraphType = typeof(graph)
+    has_image_globalref = Ref(false)
     LinearIRContext(graph, SyntaxList(ctx), ctx.bindings, Ref(0),
-                    is_toplevel_thunk, lambda_bindings, rett,
+                    is_toplevel_thunk, has_image_globalref, lambda_bindings, rett,
                     Dict{String,JumpTarget{GraphType}}(), SyntaxList(ctx), SyntaxList(ctx),
                     Vector{FinallyHandler{GraphType}}(), Dict{String,JumpTarget{GraphType}}(),
                     Vector{JumpOrigin{GraphType}}(), ctx.mod)
@@ -973,9 +975,16 @@ function _renumber(ctx, ssa_rewrites, slot_rewrites, label_table, ex)
                 if binfo.kind !== :global
                     throw(LoweringError(ex, "Found unexpected binding of kind $(binfo.kind)"))
                 end
+                if !ctx.has_image_globalref[]
+                    has_ref = 0x00 !== @ccall jl_object_in_image(binfo.mod::Any)::UInt8
+                    ctx.has_image_globalref[] = has_ref
+                end
                 makeleaf(ctx, ex, K"globalref", binfo.name, mod=binfo.mod)
             end
         end
+    elseif k == K"top" # reference to Base
+        ctx.has_image_globalref[] = true
+        ex
     elseif k == K"meta"
         # Somewhat-hack for Expr(:meta, :generated, gen) which has
         # weird top-level semantics for `gen`, but we still need to translate
@@ -1094,7 +1103,8 @@ function compile_lambda(outer_ctx, ex)
     # @info "" @ast ctx ex [K"block" ctx.code...]
     code = renumber_body(ctx, ctx.code, slot_rewrites)
     @ast ctx ex [K"code_info"(is_toplevel_thunk=ex.is_toplevel_thunk,
-                              slots=slots)
+                              slots=slots,
+                              has_image_globalref=ctx.has_image_globalref[])
         [K"block"(ex[3])
             code...
         ]
@@ -1112,13 +1122,14 @@ loops, etc) to gotos and exception handling to enter/leave. We also convert
 function linearize_ir(ctx, ex)
     graph = ensure_attributes(ctx.graph,
                               slots=Vector{Slot},
+                              has_image_globalref=Bool,
                               mod=Module,
                               id=Int)
     # TODO: Cleanup needed - `_ctx` is just a dummy context here. But currently
     # required to call reparent() ...
     GraphType = typeof(graph)
     _ctx = LinearIRContext(graph, SyntaxList(graph), ctx.bindings,
-                           Ref(0), false, LambdaBindings(), nothing,
+                           Ref(0), false, Ref(false), LambdaBindings(), nothing,
                            Dict{String,JumpTarget{typeof(graph)}}(),
                            SyntaxList(graph), SyntaxList(graph),
                            Vector{FinallyHandler{GraphType}}(),

test/misc.jl

@@ -46,4 +46,14 @@ cf_float = JuliaLowering.include_string(test_mod, """
 """)
 @test @ccall($cf_float(2::Float64, 3::Float64)::Float64) == 32.0
 
+@testset "CodeInfo: has_image_globalref" begin
+    @test JuliaLowering.lower(test_mod, parsestmt(JuliaLowering.SyntaxTree, """
+    function foo end
+    """)).has_image_globalref === false
+
+    @test JuliaLowering.lower(test_mod, parsestmt(JuliaLowering.SyntaxTree, """
+    Base.push!([], 1)
+    """)).has_image_globalref === true
+end
+
 end