Add support for breakpoints

Author: timholy

src/JuliaInterpreter.jl

@@ -11,7 +11,7 @@ using UUIDs
 using Random.DSFMT
 using InteractiveUtils
 
-export @enter, @make_stack, @interpret, Compiled, JuliaStackFrame
+export @enter, @make_stack, @interpret, Compiled, JuliaStackFrame, Breakpoints, breakpoint
 
 module CompiledCalls
 # This module is for handling intrinsics that must be compiled (llvmcall)
@@ -47,7 +47,7 @@ end
 
 """
 `JuliaFrameCode` holds static information about a method or toplevel code.
-One `JuliaFrameCode` can be shared by many `JuliaFrameState` calling frames.
+One `JuliaFrameCode` can be shared by many `JuliaStackFrame` calling frames.
 
 Important fields:
 - `scope`: the `Method` or `Module` in which this frame is to be evaluated
@@ -61,6 +61,7 @@ struct JuliaFrameCode
     scope::Union{Method,Module}
     code::CodeInfo
     methodtables::Vector{Union{Compiled,TypeMapEntry}} # line-by-line method tables for generic-function :call Exprs
+    breakpoints::Vector{Tuple{Bool,Function}}          # (isactive, condition)
     used::BitSet
     wrapper::Bool
     generator::Bool
@@ -69,7 +70,7 @@ struct JuliaFrameCode
 end
 
 function JuliaFrameCode(frame::JuliaFrameCode; wrapper = frame.wrapper, generator=frame.generator, fullpath=frame.fullpath)
-    JuliaFrameCode(frame.scope, frame.code, frame.methodtables, frame.used,
+    JuliaFrameCode(frame.scope, frame.code, frame.methodtables, frame.breakpoints, frame.used,
                    wrapper, generator, fullpath)
 end
 
@@ -80,8 +81,9 @@ function JuliaFrameCode(scope, code::CodeInfo; wrapper=false, generator=false, f
         code = copy_codeinfo(code)
         methodtables = Vector{Union{Compiled,TypeMapEntry}}(undef, length(code.code))
     end
+    breakpoints = Vector{Tuple{Bool,Function}}(undef, length(code.code))
     used = find_used(code)
-    return JuliaFrameCode(scope, code, methodtables, used, wrapper, generator, fullpath)
+    return JuliaFrameCode(scope, code, methodtables, breakpoints, used, wrapper, generator, fullpath)
 end
 
 """
@@ -211,6 +213,16 @@ function is_generated(meth)
     isdefined(meth, :generator)
 end
 
+function sparam_syms(meth::Method)
+    s = Symbol[]
+    sig = meth.sig
+    while sig isa UnionAll
+        push!(s, Symbol(sig.var.name))
+        sig = sig.body
+    end
+    return s
+end
+
 function namedtuple(kwargs)
     names, types, vals = Symbol[], [], []
     for pr in kwargs
@@ -269,6 +281,48 @@ function prepare_args(@nospecialize(f), allargs, kwargs)
     return f, allargs
 end
 
+function prepare_framecode(method::Method, argtypes; enter_generated=false)
+    sig = method.sig
+    isa(method, TypeMapEntry) && (method = method.func)
+    if method.module == Core.Compiler || method.module == Base.Threads || method ∈ compiled_methods
+        return Compiled()
+    end
+    # Get static parameters
+    (ti, lenv::SimpleVector) = ccall(:jl_type_intersection_with_env, Any, (Any, Any),
+                        argtypes, sig)::SimpleVector
+    enter_generated &= is_generated(method)
+    if is_generated(method) && !enter_generated
+        framecode = get(genframedict, (method, argtypes), nothing)
+    else
+        framecode = get(framedict, method, nothing)
+    end
+    if framecode === nothing
+        if is_generated(method) && !enter_generated
+            # If we're stepping into a staged function, we need to use
+            # the specialization, rather than stepping through the
+            # unspecialized method.
+            code = Core.Compiler.get_staged(Core.Compiler.code_for_method(method, argtypes, lenv, typemax(UInt), false))
+            code === nothing && return nothing
+            generator = false
+        else
+            if is_generated(method)
+                code = get_source(method.generator)
+                generator = true
+            else
+                code = get_source(method)
+                generator = false
+            end
+        end
+        framecode = JuliaFrameCode(method, code; generator=generator)
+        if is_generated(method) && !enter_generated
+            genframedict[(method, argtypes)] = framecode
+        else
+            framedict[method] = framecode
+        end
+    end
+    return framecode, lenv
+end
+
 function whichtt(tt)
     m = ccall(:jl_gf_invoke_lookup, Any, (Any, UInt), tt, typemax(UInt))
     m === nothing && return nothing
@@ -328,47 +382,17 @@ function prepare_call(@nospecialize(f), allargs; enter_generated = false)
         f(allargs[2:end]...)
     end
     args = allargs
-    sig = method.sig
-    isa(method, TypeMapEntry) && (method = method.func)
-    if method.module == Core.Compiler || method.module == Base.Threads || method ∈ compiled_methods
-        return Compiled()
-    end
-    # Get static parameters
-    (ti, lenv::SimpleVector) = ccall(:jl_type_intersection_with_env, Any, (Any, Any),
-                        argtypes, sig)::SimpleVector
-    enter_generated &= is_generated(method)
-    if is_generated(method) && !enter_generated
-        framecode = get(genframedict, (method, argtypes), nothing)
-    else
-        framecode = get(framedict, method, nothing)
+    ret = prepare_framecode(method, argtypes; enter_generated=enter_generated)
+    # Exceptional returns
+    if ret === nothing
+        # The generator threw an error. Let's generate the same error by calling it.
+        f(allargs[2:end]...)
     end
-    if framecode === nothing
-        if is_generated(method) && !enter_generated
-            # If we're stepping into a staged function, we need to use
-            # the specialization, rather than stepping through the
-            # unspecialized method.
-            code = Core.Compiler.get_staged(Core.Compiler.code_for_method(method, argtypes, lenv, typemax(UInt), false))
-            generator = false
-            if code === nothing
-                # The generator threw an error. Let's generate the same error by calling it.
-                f(allargs[2:end]...)
-            end
-        else
-            if is_generated(method)
-                args = Any[_Typeof(a) for a in args]
-                code = get_source(method.generator)
-                generator = true
-            else
-                code = get_source(method)
-                generator = false
-            end
-        end
-        framecode = JuliaFrameCode(method, code; generator=generator)
-        if is_generated(method) && !enter_generated
-            genframedict[(method, argtypes)] = framecode
-        else
-            framedict[method] = framecode
-        end
+    isa(ret, Compiled) && return ret
+    # Typical return
+    framecode, lenv = ret
+    if is_generated(method) && enter_generated
+        args = Any[_Typeof(a) for a in args]
     end
     return framecode, args, lenv, argtypes
 end
@@ -793,6 +817,7 @@ function prepare_locals(framecode, argvals::Vector{Any})
             pc = Ref(JuliaProgramCounter(1))
         end
         for i = 1:meth.nargs
+            last_reference[framecode.code.slotnames[i]] = i
             if meth.isva && i == meth.nargs
                 locals[i] = nargs < i ? Some{Any}(()) : (let i=i; Some{Any}(ntuple(k->argvals[i+k-1], nargs-i+1)); end)
                 break
@@ -1083,6 +1108,10 @@ function __init__()
     set_compiled_methods()
 end
 
+include("breakpoints.jl")
+using .Breakpoints
+using .Breakpoints: shouldbreak, Breakpoint
+
 include("precompile.jl")
 _precompile_()
 

src/breakpoints.jl

@@ -0,0 +1,186 @@
+module Breakpoints
+
+using ..JuliaInterpreter
+using JuliaInterpreter: JuliaFrameCode, JuliaStackFrame,
+                        prepare_framecode, framedict, get_source, sparam_syms,
+                        linenumber
+
+export breakpoint
+
+# A type that is unique to this package for which there are no valid operations
+struct Unassigned end
+
+"""
+    Breakpoint(framecode, stmtidx)
+
+A reference to a breakpoint at a particular statement index `stmtidx` in `framecode`.
+"""
+struct Breakpoint
+    framecode::JuliaFrameCode
+    stmtidx::Int
+end
+
+function Base.show(io::IO, bp::Breakpoint)
+    lineno = linenumber(bp.framecode, bp.stmtidx)
+    print(io, "breakpoint(", bp.framecode.scope, ", ", lineno, ')')
+end
+
+const _breakpoints = Set{Breakpoint}()
+
+function shouldbreak(frame, pc=frame.pc[])
+    idx = convert(Int, pc)
+    isassigned(frame.code.breakpoints, idx) || return false
+    bp = frame.code.breakpoints[idx]
+    bp[1] || return false
+    slotfunction = bp[2]
+    return slotfunction(frame)::Bool
+end
+
+function prepare_slotfunction(framecode::JuliaFrameCode, body::Union{Symbol,Expr})
+    ismeth = framecode.scope isa Method
+    uslotnames = Set{Symbol}()
+    slotnames  = Symbol[]
+    for name in framecode.code.slotnames
+        if name ∉ uslotnames
+            push!(slotnames, name)
+            push!(uslotnames, name)
+        end
+    end
+    assignments = Expr[]
+    framename = gensym("frame")
+    default = Unassigned()
+    for i = 1:length(slotnames)
+        slotname = framecode.code.slotnames[i]
+        qslotname = QuoteNode(slotname)
+        getexpr = :(something($framename.locals[$framename.last_reference[$qslotname]]))
+        push!(assignments, Expr(:(=), slotname, :(haskey($framename.last_reference, $qslotname) ? $getexpr : $default)))
+    end
+    if ismeth
+        syms = sparam_syms(framecode.scope)
+        for i = 1:length(syms)
+            push!(assignments, Expr(:(=), syms[i], :($framename.sparams[$i])))
+        end
+    end
+    funcname = ismeth ? gensym("slotfunction") : gensym(Symbol(framecode.scope.name, "_slotfunction"))
+    return Expr(:function, Expr(:call, funcname, framename), Expr(:block, assignments..., body))
+end
+
+truecondition(frame) = true
+falsecondition(frame) = false
+
+## The fundamental implementations of breakpoint-setting
+function breakpoint!(framecode::JuliaFrameCode, pc, condition::Union{Bool,Expr}=true)
+    stmtidx = convert(Int, pc)
+    if isa(condition, Bool)
+        framecode.breakpoints[stmtidx] = condition ? (true, truecondition) : (false, falsecondition)
+    else
+        fex = prepare_slotfunction(framecode, condition)
+        framecode.breakpoints[stmtidx] = (true, eval(fex))
+    end
+    bp = Breakpoint(framecode, stmtidx)
+    push!(_breakpoints, bp)
+    return bp
+end
+breakpoint!(frame::JuliaStackFrame, pc=frame.pc[], condition::Union{Bool,Expr}=true) =
+    breakpoint!(frame.code, pc, condition)
+
+function set_breakpoint_active!(framecode::JuliaFrameCode, active, pc)
+    stmtidx = convert(Int, pc)
+    _, condition = framecode.breakpoints[stmtidx]
+    framecode.breakpoints[stmtidx] = (active, condition)
+    active
+end
+set_breakpoint_active!(frame::JuliaStackFrame, active, pc) =
+    set_breakpoint_active!(frame.code, active, pc)
+
+function get_breakpoint_active(framecode::JuliaFrameCode, pc)
+    stmtidx = convert(Int, pc)
+    return framecode.breakpoints[stmtidx][1]
+end
+get_breakpoint_active(frame::JuliaStackFrame, pc) =
+    get_breakpoint_active(frame.code, pc)
+
+function toggle_breakpoint_active!(framecode::JuliaFrameCode, pc)
+    stmtidx = convert(Int, pc)
+    active, condition = framecode.breakpoints[stmtidx]
+    framecode.breakpoints[stmtidx] = (!active, condition)
+    !active
+end
+toggle_breakpoint_active!(frame::JuliaStackFrame, active, pc) =
+    toggle_breakpoint_active!(frame.code, active, pc)
+
+enable(bp::Breakpoint)  = set_breakpoint_active!(bp.framecode, true, bp.stmtidx)
+disable(bp::Breakpoint) = set_breakpoint_active!(bp.framecode, false, bp.stmtidx)
+function remove(bp::Breakpoint)
+    bp.framecode.breakpoints[bp.stmtidx] = (false, falsecondition)
+    delete!(_breakpoints, bp)
+    return nothing
+end
+
+enable() = for bp in _breakpoints enable(bp) end
+disable() = for bp in _breakpoints disable(bp) end
+function remove()
+    for bp in _breakpoints
+        bp.framecode.breakpoints[bp.stmtidx] = (false, falsecondition)
+    end
+    empty!(_breakpoints)
+    return nothing
+end
+
+"""
+    breakpoint(f, sig)
+    breakpoint(f, sig, condition)
+    breakpoint(...; enter_generated=false)
+
+Add a breakpoint upon entry to `f` with the specified argument types `sig`.
+The first will break unconditionally, the second only if `condition` evaluates to `true`.
+`condition` should be written in terms of the arguments and local variables of `f`.
+
+# Example
+```julia
+function radius2(x, y)
+    return x^2 + y^2
+end
+
+breakpoint(radius2, Tuple{Int,Int}, :(y > x))
+```
+"""
+function breakpoint(f, sig::Type, condition::Union{Bool,Expr}=true; enter_generated=false)
+    method = which(f, sig)
+    framecode, _ = prepare_framecode(method, sig; enter_generated=enter_generated)
+    breakpoint!(framecode, 1, condition)
+end
+
+"""
+    breakpoint(method::Method)
+    breakpoint(method::Method, condition::Expr)
+
+Add a breakpoint upon entry to `method`. The first will break unconditionally, the second
+only if `condition` evaluates to `true`. `condition` should be written in terms of the
+arguments and local variables of `method`.
+"""
+function breakpoint(method::Method, condition::Union{Bool,Expr}=true)
+    # FIXME: this duplicates stuff in prepare_call
+    framecode = get(framedict, method, nothing)
+    if framecode === nothing
+        code = get_source(method)
+        framecode = JuliaFrameCode(method, code; generator=false)
+        framedict[method] = framecode
+    end
+    breakpoint!(framecode, 1, condition)
+end
+
+"""
+    breakpoint(f)
+    breakpoint(f, condition)
+
+Break-on-entry to all methods of `f`.
+"""
+function breakpoint(f, condition::Union{Bool,Expr}=true)
+    for method in methods(f)
+        breakpoint(method, condition)
+    end
+    nothing
+end
+
+end