Merge pull request #81 from JuliaDebug/teh/breakpoints

Add support for breakpoints (!)

Author: timholy

src/JuliaInterpreter.jl

@@ -11,7 +11,8 @@ using UUIDs
 using Random.DSFMT
 using InteractiveUtils
 
-export @enter, @make_stack, @interpret, Compiled, JuliaStackFrame
+export @enter, @make_stack, @interpret, Compiled, JuliaStackFrame,
+       Breakpoints, breakpoint, @breakpoint, breakpoints, enable, disable, remove
 
 module CompiledCalls
 # This module is for handling intrinsics that must be compiled (llvmcall)
@@ -40,14 +41,39 @@ isless(x::JuliaProgramCounter, y::Integer) = isless(x.next_stmt, y)
 
 Base.show(io::IO, pc::JuliaProgramCounter) = print(io, "JuliaProgramCounter(", pc.next_stmt, ')')
 
+# Breakpoint support
+truecondition(frame) = true
+falsecondition(frame) = false
+const break_on_error = Ref(false)
+
+"""
+    BreakpointState(isactive=true, condition=JuliaInterpreter.truecondition)
+
+`BreakpointState` represents a breakpoint at a particular statement in
+a `JuliaFrameCode`. `isactive` indicates whether the breakpoint is currently
+[`enable`](@ref)d or [`disable`](@ref)d. `condition` is a function that accepts
+a single `JuliaStackFrame`, and `condition(frame)` must return either
+`true` or `false`. Execution will stop at a breakpoint only if `isactive`
+and `condition(frame)` both evaluate as `true`. The default `condition` always
+returns `true`.
+
+To create these objects, see [`breakpoint`](@ref).
+"""
+struct BreakpointState
+    isactive::Bool
+    condition::Function
+end
+BreakpointState(isactive::Bool) = BreakpointState(isactive, truecondition)
+BreakpointState() = BreakpointState(true)
+
 # A type used transiently in renumbering CodeInfo SSAValues (to distinguish a new SSAValue from an old one)
 struct NewSSAValue
     id::Int
 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 +87,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{BreakpointState}
     used::BitSet
     wrapper::Bool
     generator::Bool
@@ -69,7 +96,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 +107,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{BreakpointState}(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 +239,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 +307,58 @@ 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 get_framecode(method)
+    framecode = get(framedict, method, nothing)
+    if framecode === nothing
+        code = get_source(method)
+        framecode = JuliaFrameCode(method, code; generator=false)
+        framedict[method] = framecode
+    end
+    return framecode
+end
+
 function whichtt(tt)
     m = ccall(:jl_gf_invoke_lookup, Any, (Any, UInt), tt, typemax(UInt))
     m === nothing && return nothing
@@ -328,47 +418,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
@@ -795,6 +855,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
@@ -1060,8 +1121,10 @@ macro interpret(arg)
         if frame === nothing
             return eval(Expr(:call, map(QuoteNode, theargs)...))
         end
-        empty!(framedict)  # start fresh each time; kind of like bumping the world age at the REPL prompt
-        empty!(genframedict)
+        if shouldbreak(frame, 1)
+            push!(stack, frame)
+            return stack, BreakpointRef(frame.code, 1)
+        end
         finish_and_return!(stack, frame)
     end
 end
@@ -1085,6 +1148,10 @@ function __init__()
     set_compiled_methods()
 end
 
+include("breakpoints.jl")
+using .Breakpoints
+using .Breakpoints: shouldbreak, BreakpointRef
+
 include("precompile.jl")
 _precompile_()