Merge pull request #412 from JuliaDebug/teh/new_nodes

Support ReturnNode and GotoIfNot

Author: timholy

src/commands.jl

@@ -175,7 +175,7 @@ function next_line!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=false
     return _next_line!(recurse, frame, istoplevel, initialline, initialfile) # avoid boxing
 end
 function _next_line!(@nospecialize(recurse), frame, istoplevel, initialline::Int, initialfile::String)
-    predicate(frame) = isexpr(pc_expr(frame), :return) || (linenumber(frame) != initialline || getfile(frame) != initialfile)
+    predicate(frame) = is_return(pc_expr(frame)) || (linenumber(frame) != initialline || getfile(frame) != initialfile)
 
     pc = next_until!(predicate, recurse, frame, istoplevel)
     (pc === nothing || isa(pc, BreakpointRef)) && return pc
@@ -195,7 +195,7 @@ function until_line!(@nospecialize(recurse), frame::Frame, line::Union{Nothing,
     pc = frame.pc
     initialline, initialfile = linenumber(frame, pc), getfile(frame, pc)
     line === nothing && (line = initialline + 1)
-    predicate(frame) = isexpr(pc_expr(frame), :return) || (linenumber(frame) >= line && getfile(frame) == initialfile)
+    predicate(frame) = is_return(pc_expr(frame)) || (linenumber(frame) >= line && getfile(frame) == initialfile)
     pc = next_until!(predicate, frame, istoplevel)
     (pc === nothing || isa(pc, BreakpointRef)) && return pc
     maybe_step_through_kwprep!(recurse, frame, istoplevel)
@@ -443,7 +443,7 @@ function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootis
             is_si || maybe_step_through_kwprep!(recurse, frame, istoplevel)
             pc = frame.pc
             stmt0 = stmt = pc_expr(frame, pc)
-            isexpr(stmt0, :return) && return maybe_reset_frame!(recurse, frame, nothing, rootistoplevel)
+            is_return(stmt0) && return maybe_reset_frame!(recurse, frame, nothing, rootistoplevel)
             if isexpr(stmt, :(=))
                 stmt = stmt.args[2]
             end

src/interpret.jl

@@ -417,7 +417,7 @@ function check_isdefined(frame, @nospecialize(node))
     error("unrecognized isdefined node ", node)
 end
 
-# For "profiling" where JuliaIntepreter spends its time. See the commented-out block
+# For "profiling" where JuliaInterpreter spends its time. See the commented-out block
 # in `step_expr!`
 const _location = Dict{Tuple{Method,Int},Int}()
 
@@ -449,7 +449,7 @@ function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplev
             elseif node.head === :gotoifnot
                 arg = @lookup(frame, node.args[1])
                 if !isa(arg, Bool)
-                    throw(TypeError(nameof(frame), "if", Bool, node.args[1]))
+                    throw(TypeError(nameof(frame), "if", Bool, arg))
                 end
                 if !arg
                     return (frame.pc = node.args[2]::Int)
@@ -528,6 +528,17 @@ function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplev
             end
         elseif isa(node, GotoNode)
             return (frame.pc = node.label)
+        elseif is_GotoIfNot(node)
+            node = node::Core.GotoIfNot
+            arg = @lookup(frame, node.cond)
+            if !isa(arg, Bool)
+                throw(TypeError(nameof(frame), "if", Bool, arg))
+            end
+            if !arg
+                return (frame.pc = node.dest)
+            end
+        elseif is_ReturnNode(node)
+            return nothing
         elseif isa(node, NewvarNode)
             # FIXME: undefine the slot?
         elseif istoplevel && isa(node, LineNumberNode)
@@ -606,6 +617,12 @@ function handle_err(@nospecialize(recurse), frame, err)
     return (frame.pc = data.exception_frames[end])
 end
 
+if isdefined(Core, :ReturnNode)
+    lookup_return(frame, node::Core.ReturnNode) = @lookup(frame, node.val)
+else
+    lookup_return(frame, node::Expr) = @lookup(frame, node.args[1])
+end
+
 """
     ret = get_return(frame)
 
@@ -615,7 +632,7 @@ e.g., [`JuliaInterpreter.finish!`](@ref)).
 """
 function get_return(frame)
     node = pc_expr(frame)
-    isexpr(node, :return) || error("expected return statement, got ", node)
-    return @lookup(frame, (node::Expr).args[1])
+    is_return(node) || error("expected return statement, got ", node)
+    return lookup_return(frame, node)
 end
 get_return(t::Tuple{Module,Expr,Frame}) = get_return(t[end])

src/optimize.jl

@@ -52,6 +52,17 @@ function renumber_ssa!(stmts::Vector{Any}, ssalookup)
             if (stmt.head === :gotoifnot || stmt.head === :enter) && isa(stmt.args[end], Int)
                 stmt.args[end] = ssalookup[stmt.args[end]]
             end
+        elseif is_GotoIfNot(stmt)
+            cond = stmt.cond
+            if isa(cond, SSAValue)
+                cond = SSAValue(ssalookup[cond.id])
+            end
+            stmts[i] = Core.GotoIfNot(cond, ssalookup[stmt.dest])
+        elseif is_ReturnNode(stmt)
+            val = (stmt::Core.ReturnNode).val
+            if isa(val, SSAValue)
+                stmts[i] = Core.ReturnNode(SSAValue(ssalookup[val.id]))
+            end
         end
     end
     return stmts
@@ -372,11 +383,33 @@ function replace_coretypes!(src; rev::Bool=false)
 end
 
 function replace_coretypes_list!(list::AbstractVector; rev::Bool)
+    function rep(@nospecialize(x), rev::Bool)
+        if isa(x, rev ? SSAValue : Core.SSAValue)
+            return rev ? Core.SSAValue(x.id) : SSAValue(x.id)
+        elseif isa(x, rev ? SlotNumber : Core.SlotNumber)
+            return rev ? Core.SlotNumber(x.id) : SlotNumber(x.id)
+        end
+        return x
+    end
+
     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)
+        rstmt = rep(stmt, rev)
+        if rstmt !== stmt
+            list[i] = rstmt
+        elseif is_GotoIfNot(stmt)
+            stmt = stmt::Core.GotoIfNot
+            cond = stmt.cond
+            rcond = rep(cond, rev)
+            if rcond !== cond
+                list[i] = Core.GotoIfNot(rcond, stmt.dest)
+            end
+        elseif is_ReturnNode(stmt)
+            stmt = stmt::Core.ReturnNode
+            val = stmt.val
+            rval = rep(val, rev)
+            if rval !== val
+                list[i] = Core.ReturnNode(rval)
+            end
         elseif isa(stmt, Expr)
             replace_coretypes!(stmt; rev=rev)
         end

src/utils.jl

@@ -132,7 +132,23 @@ _scopename(parent, child, rest...) = Expr(:., parent, _scopename(child, rest...)
 
 isidentical(x) = Base.Fix2(===, x)   # recommended over isequal(::Symbol) since it cannot be invalidated
 
-is_goto_node(@nospecialize(node)) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
+# is_goto_node(@nospecialize(node)) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
+
+if isdefined(Core, :GotoIfNot)
+    is_GotoIfNot(@nospecialize(node)) = isa(node, Core.GotoIfNot)
+    is_gotoifnot(@nospecialize(node)) = is_GotoIfNot(node)
+else
+    is_GotoIfNot(@nospecialize(node)) = false
+    is_gotoifnot(@nospecialize(node)) = isexpr(node, :gotoifnot)
+end
+
+if isdefined(Core, :ReturnNode)
+    is_ReturnNode(@nospecialize(node)) = isa(node, Core.ReturnNode)
+    is_return(@nospecialize(node)) = is_ReturnNode(node)
+else
+    is_ReturnNode(@nospecialize(node)) = false
+    is_return(@nospecialize(node)) = isexpr(node, :return)
+end
 
 is_loc_meta(@nospecialize(expr), @nospecialize(kind)) = isexpr(expr, :meta) && length(expr.args) >= 1 && expr.args[1] === kind
 
@@ -165,7 +181,7 @@ function is_call(@nospecialize(node))
         (isexpr(node, :(=)) && (isexpr(node.args[2], :call)))
 end
 
-is_call_or_return(@nospecialize(node)) = is_call(node) || isexpr(node, :return)
+is_call_or_return(@nospecialize(node)) = is_call(node) || is_return(node)
 
 is_dummy(bpref::BreakpointRef) = bpref.stmtidx == 0 && bpref.err === nothing
 
@@ -253,7 +269,7 @@ function linetable(arg)
     end
     return (arg::CodeInfo).linetable::Vector{Any}
 end
-linetable(arg, i::Integer) = linetable(arg)[i]::LineTypes
+linetable(arg, i::Integer) = linetable(arg)[i]::Union{Expr,LineTypes}
 
 function codelocs(arg)
     if isa(arg, Frame)

test/debug.jl

@@ -135,17 +135,19 @@ end
         @test isa(pc, BreakpointRef)
         @test JuliaInterpreter.scopeof(f).name == :generatedfoo
         stmt = JuliaInterpreter.pc_expr(f)
-        @test stmt.head == :return && stmt.args[1] === Int
+        @test JuliaInterpreter.is_return(stmt) && JuliaInterpreter.lookup_return(frame, stmt) === Int
         @test debug_command(frame, :c) === nothing
         @test frame.callee === nothing
         @test get_return(frame) === Int
         # This time, step into the generated function itself
         frame = enter_call_expr(:($(callgenerated)()))
         f, pc = debug_command(frame, :sg)
+            # Aside: generators can have `Expr(:line, ...)` in their line tables, test that this is OK
+            @test isexpr(JuliaInterpreter.linetable(f, 2), :line)
         @test isa(pc, BreakpointRef)
         @test JuliaInterpreter.scopeof(f).name == :generatedfoo
         stmt = JuliaInterpreter.pc_expr(f)
-        @test stmt.head == :return && @lookup(f, stmt.args[1]) === 1
+        @test JuliaInterpreter.is_return(stmt) && JuliaInterpreter.lookup_return(f, stmt) === 1
         f2, pc = debug_command(f, :finish)
         @test JuliaInterpreter.scopeof(f2).name == :callgenerated
         # Now finish the regular function

test/limits.jl

@@ -32,7 +32,7 @@ using Test
     @test Aborted(frame, i).at.line == 6
     # Check conditional
     frame = JuliaInterpreter.prepare_thunk(modexs[4])
-    i = findfirst(stmt->isexpr(stmt, :gotoifnot), frame.framecode.src.code) + 1
+    i = findfirst(stmt->JuliaInterpreter.is_gotoifnot(stmt), frame.framecode.src.code) + 1
     @test Aborted(frame, i).at.line == 9
     # Check macro
     frame = JuliaInterpreter.prepare_thunk(modexs[5])

test/utils.jl

@@ -84,7 +84,7 @@ function evaluate_limited!(@nospecialize(recurse), frame::Frame, nstmts::Int, is
                 nstmts = refnstmts[]
             elseif istoplevel && stmt.head == :thunk
                 code = stmt.args[1]
-                if length(code.code) == 1 && isexpr(code.code[end], :return) && isexpr(code.code[end].args[1], :method)
+                if length(code.code) == 1 && JuliaInterpreter.is_return(code.code[end]) && isexpr(code.code[end].args[1], :method)
                     # Julia 1.2+ puts a :thunk before the start of each method
                     new_pc = pc + 1
                 else
@@ -121,7 +121,7 @@ function evaluate_limited!(@nospecialize(recurse), frame::Frame, nstmts::Int, is
     end
     # Handle the return
     stmt = pc_expr(frame, pc)
-    if nstmts == 0 && !isexpr(stmt, :return)
+    if nstmts == 0 && !JuliaInterpreter.is_return(stmt)
         ret = Aborted(frame, pc)
         return ret, nstmts
     end