Merge pull request #127 from JuliaDebug/kc/unwind_exc

Debug commands: implement unwinding of stack on thrown exception

Author: timholy

src/commands.jl

@@ -272,6 +272,24 @@ function maybe_reset_frame!(@nospecialize(recurse), frame::Frame, @nospecialize(
     return frame, pc
 end
 
+# Unwind the stack until an exc is eventually caught, thereby
+# returning the frame that caught the exception at the pc of the catch
+# or rethrow the error
+function unwind_exception(frame::Frame, exc)
+    while frame !== nothing
+        if !isempty(frame.framedata.exception_frames)
+            # Exception caught
+            frame.pc = frame.framedata.exception_frames[end]
+            frame.framedata.last_exception[] = exc
+            return frame
+        end
+        # recycle(frame)
+        frame = caller(frame)
+        frame === nothing || (frame.callee = nothing)
+    end
+    rethrow(exc)
+end
+
 """
     ret = debug_command(recurse, frame, cmd, rootistoplevel=false)
     ret = debug_command(frame, cmd, rootistoplevel=false)
@@ -294,40 +312,48 @@ or one of the 'advanced' commands
 Unlike other commands, the default setting for `recurse` is `Compiled()`.
 """
 function debug_command(@nospecialize(recurse), frame::Frame, cmd::AbstractString, rootistoplevel::Bool=false)
-    # ::Union{Val{:nc},Val{:n},Val{:se}},
-    # Need try/catch
     istoplevel = rootistoplevel && frame.caller === nothing
-    cmd == "nc" && return maybe_reset_frame!(recurse, frame, next_call!(recurse, frame, istoplevel), rootistoplevel)
-    cmd == "n" && return maybe_reset_frame!(recurse, frame, next_line!(recurse, frame, istoplevel), rootistoplevel)
     if cmd == "si"
         stmt = pc_expr(frame)
         cmd = is_call(stmt) ? "s" : "se"
     end
-    cmd == "se" && return maybe_reset_frame!(recurse, frame, step_expr!(recurse, frame, istoplevel), rootistoplevel)
-    enter_generated = false
-    if cmd == "sg"
-        enter_generated = true
-        cmd = "s"
-    end
-    if cmd == "s"
-        pc = maybe_next_call!(recurse, frame, istoplevel)
-        (isa(pc, BreakpointRef) || pc === nothing) && return maybe_reset_frame!(recurse, frame, pc, rootistoplevel)
-        stmt0 = stmt = pc_expr(frame, pc)
-        if isexpr(stmt, :(=))
-            stmt = stmt.args[2]
+    try 
+        cmd == "nc" && return maybe_reset_frame!(recurse, frame, next_call!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == "n" && return maybe_reset_frame!(recurse, frame, next_line!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == "se" && return maybe_reset_frame!(recurse, frame, step_expr!(recurse, frame, istoplevel), rootistoplevel)
+   
+        enter_generated = false
+        if cmd == "sg"
+            enter_generated = true
+            cmd = "s"
+        end
+        if cmd == "s"
+            pc = maybe_next_call!(recurse, frame, istoplevel)
+            (isa(pc, BreakpointRef) || pc === nothing) && return maybe_reset_frame!(recurse, frame, pc, rootistoplevel)
+            stmt0 = stmt = pc_expr(frame, pc)
+            if isexpr(stmt, :(=))
+                stmt = stmt.args[2]
+            end
+            ret = evaluate_call!(dummy_breakpoint, frame, stmt; enter_generated=enter_generated)
+            isa(ret, BreakpointRef) && return maybe_reset_frame!(recurse, frame, ret, rootistoplevel)
+            maybe_assign!(frame, stmt0, ret)
+            frame.pc = ret + 1
+            return frame, frame.pc
+        end
+        if cmd == "c"
+            r = root(frame)
+            ret = finish_stack!(recurse, r, rootistoplevel)
+            return isa(ret, BreakpointRef) ? (leaf(r), ret) : nothing
+        end
+        cmd == "finish" && return maybe_reset_frame!(recurse, frame, finish!(recurse, frame, istoplevel), rootistoplevel)
+    catch err
+        frame = unwind_exception(frame, err)
+        if cmd == "c"
+            return debug_command(recurse, frame, "c", istoplevel)
+        else
+            return debug_command(recurse, frame, "nc", istoplevel)
         end
-        ret = evaluate_call!(dummy_breakpoint, frame, stmt; enter_generated=enter_generated)
-        isa(ret, BreakpointRef) && return maybe_reset_frame!(recurse, frame, ret, rootistoplevel)
-        maybe_assign!(frame, stmt0, ret)
-        frame.pc = ret + 1
-        return frame, frame.pc
-    end
-    if cmd == "c"
-        r = root(frame)
-        ret = finish_stack!(recurse, r, rootistoplevel)
-        return isa(ret, BreakpointRef) ? (leaf(r), ret) : nothing
     end
-    cmd == "finish" && return maybe_reset_frame!(recurse, frame, finish!(recurse, frame, istoplevel), rootistoplevel)
     throw(ArgumentError("command $cmd not recognized"))
 end
 debug_command(frame::Frame, cmd::AbstractString, rootistoplevel::Bool=false) =

test/debug.jl

@@ -128,4 +128,52 @@ end
         @test get_return(frame) == 3
     end
 
+    @testset "Exceptions" begin
+        # Don't break on caught exceptions
+        err_caught = Any[nothing]
+        function f_exc_outer()
+            try 
+                f_exc_inner()
+            catch err;
+                err_caught[1] = err
+            end
+            x = 1 + 1
+            return x
+        end
+        f_exc_inner() = error()
+        fr = JuliaInterpreter.enter_call(f_exc_outer)
+        fr, pc = debug_command(fr, "s")
+        fr, pc = debug_command(fr, "n")
+        fr, pc = debug_command(fr, "n")
+        debug_command(fr, "finish")
+        @test get_return(fr) == 2
+        @test first(err_caught) isa ErrorException
+        @test stacklength(fr) == 1
+
+        err_caught = Any[nothing]
+        fr = JuliaInterpreter.enter_call(f_exc_outer)
+        fr, pc = debug_command(fr, "s")
+        debug_command(fr, "c")
+        @test get_return(root(fr)) == 2
+        @test first(err_caught) isa ErrorException
+        @test stacklength(root(fr)) == 1
+
+        # Rethrow on uncaught exceptions
+        f_outer() = g_inner()
+        g_inner() = error()
+        fr = JuliaInterpreter.enter_call(f_outer)
+        @test_throws ErrorException debug_command(fr, "finish")
+        @test stacklength(fr) == 1
+
+        # Break on error
+        try
+            JuliaInterpreter.break_on_error[] = true
+            fr = JuliaInterpreter.enter_call(f_outer)
+            fr, pc = debug_command(JuliaInterpreter.finish_and_return!, fr, "finish")
+            @test fr.framecode.scope.name == :error
+        finally
+            JuliaInterpreter.break_on_error[] = false
+        end
+    end
+
 # end

test/utils.jl

@@ -6,6 +6,16 @@ using JuliaInterpreter: finish_and_return!, evaluate_call!, step_expr!, shouldbr
 using Base.Meta: isexpr
 using Test, Random, SHA
 
+function stacklength(frame)
+    n = 1
+    frame = frame.callee
+    while frame !== nothing
+        n += 1
+        frame = frame.callee
+    end
+    return n
+end
+
 # Execute a frame using Julia's regular compiled-code dispatch for any :call expressions
 runframe(frame) = Some{Any}(finish_and_return!(Compiled(), frame))