Interpret most of Core.Compiler (#277)

* Define our own `SSAValue` and `SlotNumber` types to distinguish them from values generated in `Core.Compiler`
* `eval` the compiled `ccalls` from `Core.Compiler` in that module
* re-use previous compiled-`ccalls` based on arg types

Author: timholy

src/JuliaInterpreter.jl

@@ -2,7 +2,7 @@ module JuliaInterpreter
 
 using Base.Meta
 import Base: +, -, convert, isless
-using Core: CodeInfo, SSAValue, SlotNumber, TypeMapEntry, SimpleVector, LineInfoNode, GotoNode, Slot,
+using Core: CodeInfo, TypeMapEntry, SimpleVector, LineInfoNode, GotoNode, Slot,
             GeneratedFunctionStub, MethodInstance, NewvarNode, TypeName
 
 using UUIDs
@@ -18,7 +18,7 @@ export @interpret, Compiled, Frame, root, leaf,
        debug_command, @bp, break_on, break_off
 
 module CompiledCalls
-# This module is for handling intrinsics that must be compiled (llvmcall)
+# This module is for handling intrinsics that must be compiled (llvmcall) as well as ccalls
 end
 
 # "Backport" of https://github.com/JuliaLang/julia/pull/31536
@@ -70,12 +70,43 @@ function set_compiled_methods()
     push!(compiled_methods, which(subtypes, Tuple{Module, Type}))
     push!(compiled_methods, which(subtypes, Tuple{Type}))
 
-    push!(compiled_modules, Core.Compiler)
+    # Anything that ccalls jl_typeinf_begin cannot currently be handled
+    for finf in (Core.Compiler.typeinf_code, Core.Compiler.typeinf_ext, Core.Compiler.typeinf_type)
+        for m in methods(finf)
+            push!(compiled_methods, m)
+        end
+    end
+
     push!(compiled_modules, Base.Threads)
 end
 
 function __init__()
     set_compiled_methods()
+    # If we interpret into Core.Compiler, we need to take precautions to avoid needing
+    # inference of JuliaInterpreter methods in the middle of a `ccall(:jl_typeinf_begin, ...)`
+    # block.
+    # for (sym, RT, AT) in ((:jl_typeinf_begin, Cvoid, ()),
+    #                       (:jl_typeinf_end, Cvoid, ()),
+    #                       (:jl_isa_compileable_sig, Int32, (Any, Any)),
+    #                       (:jl_compress_ast, Any, (Any, Any)),
+    #                       # (:jl_set_method_inferred, Ref{Core.CodeInstance}, (Any, Any, Any, Any, Int32, UInt, UInt)),
+    #                       (:jl_method_instance_add_backedge, Cvoid, (Any, Any)),
+    #                       (:jl_method_table_add_backedge, Cvoid, (Any, Any, Any)),
+    #                       (:jl_new_code_info_uninit, Ref{CodeInfo}, ()),
+    #                       (:jl_uncompress_argnames, Vector{Symbol}, (Any,)),
+    #                       (:jl_get_tls_world_age, UInt, ()),
+    #                       (:jl_call_in_typeinf_world, Any, (Ptr{Ptr{Cvoid}}, Cint)),
+    #                       (:jl_value_ptr, Any, (Ptr{Cvoid},)),
+    #                       (:jl_value_ptr, Ptr{Cvoid}, (Any,)))
+    #     fname = Symbol(:ccall_, sym)
+    #     qsym = QuoteNode(sym)
+    #     argnames = [Symbol(:arg_, string(i)) for i = 1:length(AT)]
+    #     TAT = Expr(:tuple, [parametric_type_to_expr(t) for t in AT]...)
+    #     def = :($fname($(argnames...)) = ccall($qsym, $RT, $TAT, $(argnames...)))
+    #     f = Core.eval(Core.Compiler, def)
+    #     compiled_calls[(qsym, RT, Core.svec(AT...), Core.Compiler)] = f
+    #     precompile(f, AT)
+    # end
 end
 
 include("precompile.jl")

src/commands.jl

@@ -213,7 +213,7 @@ function maybe_step_through_wrapper!(@nospecialize(recurse), frame::Frame)
     last = stmts[end-1]
     isexpr(last, :(=)) && (last = last.args[2])
     is_kw = isa(scope, Method) && startswith(String(Base.unwrap_unionall(Base.unwrap_unionall(scope.sig).parameters[1]).name.name), "#kw")
-    if is_kw || isexpr(last, :call) && any(isequal(Core.SlotNumber(1)), last.args)
+    if is_kw || isexpr(last, :call) && any(isequal(SlotNumber(1)), last.args)
         # If the last expr calls #self# or passes it to an implementation method,
         # this is a wrapper function that we might want to step through
         while frame.pc != length(stmts)-1

src/interpret.jl

@@ -178,7 +178,8 @@ function bypass_builtins(frame, call_expr, pc)
         if isa(tme, Compiled)
             fargs = collect_args(frame, call_expr)
             f = to_function(fargs[1])
-            if parentmodule(f) === JuliaInterpreter.CompiledCalls
+            fmod = parentmodule(f)
+            if fmod === JuliaInterpreter.CompiledCalls || fmod === Core.Compiler
                 return Some{Any}(Base.invokelatest(f, fargs[2:end]...))
             else
                 return Some{Any}(f(fargs[2:end]...))

src/optimize.jl

@@ -1,5 +1,7 @@
 const calllike = Set([:call, :foreigncall])
 
+const compiled_calls = Dict{Any,Any}()
+
 function extract_inner_call!(stmt, idx, once::Bool=false)
     isa(stmt, Expr) || return nothing
     (stmt.head == :toplevel || stmt.head == :thunk) && return nothing
@@ -127,8 +129,10 @@ which this will run) and ensures that no statement includes nested `:call` expre
 """
 function optimize!(code::CodeInfo, scope)
     mod = moduleof(scope)
+    evalmod = mod == Core.Compiler ? Core.Compiler : CompiledCalls
     sparams = scope isa Method ? Symbol[sparam_syms(scope)...] : Symbol[]
     code.inferred && error("optimization of inferred code not implemented")
+    replace_coretypes!(code)
     # TODO: because of builtins.jl, for CodeInfos like
     #   %1 = Core.apply_type
     #   %2 = (%1)(args...)
@@ -163,7 +167,7 @@ function optimize!(code::CodeInfo, scope)
                 ustr = replace(string(uuid), '-'=>'_')
                 methname = Symbol("llvmcall_", ustr)
                 nargs = length(stmt.args)-4
-                delete_idx = build_compiled_call!(stmt, methname, Base.llvmcall, stmt.args[2:4], code, idx, nargs, sparams)
+                delete_idx = build_compiled_call!(stmt, methname, Base.llvmcall, stmt.args[2:4], code, idx, nargs, sparams, evalmod)
                 push!(foreigncalls_idx, idx)
                 append!(delete_idxs, delete_idx)
             end
@@ -189,7 +193,7 @@ function optimize!(code::CodeInfo, scope)
             ustr = replace(string(uuid), '-'=>'_')
             methname = Symbol("ccall", '_', f, '_', ustr)
             nargs = stmt.args[5]
-            delete_idx = build_compiled_call!(stmt, methname, :ccall, stmt.args[1:3], code, idx, nargs, sparams)
+            delete_idx = build_compiled_call!(stmt, methname, :ccall, stmt.args[1:3], code, idx, nargs, sparams, evalmod)
             push!(foreigncalls_idx, idx)
             append!(delete_idxs, delete_idx)
         end
@@ -239,14 +243,15 @@ end
 function parametric_type_to_expr(t::Type)
     t isa Core.TypeofBottom && return t
     t isa UnionAll && (t = t.body)
-    if t <: Vararg 
+    if t <: Vararg
         return Expr(:(...), t.parameters[1])
     end
     return t.hasfreetypevars ? Expr(:curly, t.name.name, ((tv-> tv isa TypeVar ? tv.name : tv).(t.parameters))...) : t
 end
 
 # Handle :llvmcall & :foreigncall (issue #28)
-function build_compiled_call!(stmt, methname, fcall, typargs, code, idx, nargs, sparams)
+function build_compiled_call!(stmt, methname, fcall, typargs, code, idx, nargs, sparams, evalmod)
+    TVal = evalmod == Core.Compiler ? Core.Compiler.Val : Val
     argnames = Any[Symbol("arg", string(i)) for i = 1:nargs]
     delete_idx = Int[]
     if fcall == :ccall
@@ -287,48 +292,74 @@ function build_compiled_call!(stmt, methname, fcall, typargs, code, idx, nargs,
         cfunc, RetType, ArgType = @lookup(frame, stmt.args[2]), @lookup(frame, stmt.args[3]), @lookup(frame, stmt.args[4])
         args = stmt.args[5:end]
     end
-    if isa(cfunc, Expr)
+    if isa(cfunc, Expr)   # specification by tuple, e.g., (:clock, "libc")
         cfunc = eval(cfunc)
     end
     if isa(cfunc, Symbol)
         cfunc = QuoteNode(cfunc)
     end
-    if fcall == :ccall
-        ArgType = Expr(:tuple, [parametric_type_to_expr(t) for t in ArgType]...)
-    end
     if isa(RetType, SimpleVector)
         @assert length(RetType) == 1
         RetType = RetType[1]
     end
-    RetType = parametric_type_to_expr(RetType)
-    wrapargs = copy(argnames)
-    for sparam in sparams
-        push!(wrapargs, :(::Val{$sparam}))
-    end
-    if stmt.args[4] == :(:llvmcall)
-        def = :(
-            function $methname($(wrapargs...)) where {$(sparams...)}
-                return $fcall($cfunc, llvmcall, $RetType, $ArgType, $(argnames...))
-            end)
-    elseif stmt.args[4] == :(:stdcall)
-        def = :(
-            function $methname($(wrapargs...)) where {$(sparams...)}
-                return $fcall($cfunc, stdcall, $RetType, $ArgType, $(argnames...))
-            end)
-    else
-        def = :(
-            function $methname($(wrapargs...)) where {$(sparams...)}
-                return $fcall($cfunc, $RetType, $ArgType, $(argnames...))
-            end)
+    cc_key = (cfunc, RetType, ArgType, evalmod)  # compiled call key
+    f = get(compiled_calls, cc_key, nothing)
+    if f === nothing
+        if fcall == :ccall
+            ArgType = Expr(:tuple, [parametric_type_to_expr(t) for t in ArgType]...)
+        end
+        RetType = parametric_type_to_expr(RetType)
+        wrapargs = copy(argnames)
+        for sparam in sparams
+            push!(wrapargs, :(::$TVal{$sparam}))
+        end
+        if stmt.args[4] == :(:llvmcall)
+            def = :(
+                function $methname($(wrapargs...)) where {$(sparams...)}
+                    return $fcall($cfunc, llvmcall, $RetType, $ArgType, $(argnames...))
+                end)
+        elseif stmt.args[4] == :(:stdcall)
+            def = :(
+                function $methname($(wrapargs...)) where {$(sparams...)}
+                    return $fcall($cfunc, stdcall, $RetType, $ArgType, $(argnames...))
+                end)
+        else
+            def = :(
+                function $methname($(wrapargs...)) where {$(sparams...)}
+                    return $fcall($cfunc, $RetType, $ArgType, $(argnames...))
+                end)
+        end
+        f = Core.eval(evalmod, def)
+        compiled_calls[cc_key] = f
     end
-    f = Core.eval(CompiledCalls, def)
     stmt.args[1] = QuoteNode(f)
     stmt.head = :call
     deleteat!(stmt.args, 2:length(stmt.args))
     append!(stmt.args, args)
     for i in 1:length(sparams)
-        push!(stmt.args, :($Val($(Expr(:static_parameter, i)))))
+        push!(stmt.args, :($TVal($(Expr(:static_parameter, i)))))
     end
     return delete_idx
 end
 
+function replace_coretypes!(src; rev::Bool=false)
+    if isa(src, CodeInfo)
+        replace_coretypes_list!(src.code; rev=rev)
+    elseif isa(src, Expr)
+        replace_coretypes_list!(src.args; rev=rev)
+    end
+    return src
+end
+
+function replace_coretypes_list!(list; rev::Bool)
+    for (i, stmt) in enumerate(list)
+        if isa(stmt, rev ? SSAValue : Core.SSAValue)
+            list[i] = rev ? Core.SSAValue(stmt.id) : SSAValue(stmt.id)
+        elseif isa(stmt, rev ? SlotNumber : Core.SlotNumber)
+            list[i] = rev ? Core.SlotNumber(stmt.id) : SlotNumber(stmt.id)
+        elseif isa(stmt, Expr)
+            replace_coretypes!(stmt; rev=rev)
+        end
+    end
+    return nothing
+end

src/types.jl

@@ -11,6 +11,15 @@ struct NewSSAValue
     id::Int
 end
 
+# Our own replacements for Core types. We need to do this to ensure we can tell the difference
+# between "data" (Core types) and "code" (our types) if we step into Core.Compiler
+struct SSAValue
+    id::Int
+end
+struct SlotNumber
+    id::Int
+end
+
 # Breakpoint support
 truecondition(frame) = true
 falsecondition(frame) = false
@@ -70,7 +79,7 @@ function FrameCode(scope, src::CodeInfo; generator=false, optimize=true)
     if optimize
         src, methodtables = optimize!(copy_codeinfo(src), scope)
     else
-        src = copy_codeinfo(src)
+        src = replace_coretypes!(copy_codeinfo(src))
         methodtables = Vector{Union{Compiled,TypeMapEntry}}(undef, length(src.code))
     end
     breakpoints = Vector{BreakpointState}(undef, length(src.code))

src/utils.jl

@@ -61,16 +61,32 @@ function find_used(code::CodeInfo)
     used = BitSet()
     stmts = code.code
     for stmt in stmts
-        Core.Compiler.scan_ssa_use!(push!, used, stmt)
-        if isexpr(stmt, :struct_type)  # this one is missed
+        scan_ssa_use!(used, stmt)
+        if isexpr(stmt, :struct_type)  # this one is missed by Core.Compiler.userefs
             for a in stmt.args
-                Core.Compiler.scan_ssa_use!(push!, used, a)
+                scan_ssa_use!(used, a)
             end
         end
     end
     return used
 end
 
+function scan_ssa_use!(used::BitSet, @nospecialize(stmt))
+    if isa(stmt, SSAValue)
+        push!(used, stmt.id)
+    end
+    iter = Core.Compiler.userefs(stmt)
+    iterval = Core.Compiler.iterate(iter)
+    while iterval !== nothing
+        useref, state = iterval
+        val = Core.Compiler.getindex(useref)
+        if isa(val, SSAValue)
+            push!(used, val.id)
+        end
+        iterval = Core.Compiler.iterate(iter, state)
+    end
+end
+
 ## Predicates
 
 is_goto_node(@nospecialize(node)) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
@@ -265,7 +281,9 @@ function print_framecode(io::IO, framecode::FrameCode; pc=0, range=1:nstatements
     offset = lineoffset(framecode)
     ndline = isempty(lt) ? 0 : ndigits(getline(lt[end]) + offset)
     nullline = " "^ndline
-    code = framecode_lines(framecode)
+    src = copy_codeinfo(framecode.src)
+    replace_coretypes!(src; rev=true)
+    code = framecode_lines(src)
     isfirst = true
     for (stmtidx, stmtline) in enumerate(code)
         stmtidx ∈ range || continue

test/interpret.jl

@@ -337,7 +337,7 @@ f113(;x) = x
     end
     frame = JuliaInterpreter.enter_call(f_multi, 1)
     nlocals = length(frame.framedata.locals)
-    @test_throws UndefVarError JuliaInterpreter.lookup_var(frame, Core.SlotNumber(nlocals))
+    @test_throws UndefVarError JuliaInterpreter.lookup_var(frame, JuliaInterpreter.SlotNumber(nlocals))
     stack = [frame]
     locals = JuliaInterpreter.locals(frame)
     @test length(locals) == 2
@@ -383,7 +383,7 @@ end
         end
     end
     @test @interpret(test_never_different(10)) === nothing
-  
+
 end
 
 # https://github.com/JuliaDebug/JuliaInterpreter.jl/issues/130
@@ -516,3 +516,10 @@ end
 # Test exception type for undefined variables
 f() = s = s + 1
 @test_throws UndefVarError @interpret f()
+
+# Handling of SSAValues
+function f()
+    z = [Core.SSAValue(5),]
+    repr(z[1])
+end
+@test @interpret f() == f()