Merge pull request #124 from JuliaDebug/teh/ll

Linked-list implementation

Author: timholy

docs/src/dev_reference.md

@@ -21,6 +21,13 @@ JuliaInterpreter.get_call_framecode
 JuliaInterpreter.optimize!
 ```
 
+## Frame traversal
+
+```@docs
+root
+leaf
+```
+
 ## Frame execution
 
 ```@docs
@@ -33,8 +40,10 @@ JuliaInterpreter.get_return
 JuliaInterpreter.next_until!
 JuliaInterpreter.through_methoddef_or_done!
 JuliaInterpreter.evaluate_call!
-JuliaInterpreter.evaluate_foreigncall!
+JuliaInterpreter.evaluate_foreigncall
 JuliaInterpreter.maybe_evaluate_builtin
+JuliaInterpreter.maybe_next_call!
+JuliaInterpreter.handle_err
 ```
 
 ## Breakpoints
@@ -45,14 +54,16 @@ breakpoint
 enable
 disable
 remove
+JuliaInterpreter.dummy_breakpoint
 ```
 
 ## Types
 
 ```@docs
-JuliaInterpreter.JuliaStackFrame
-JuliaInterpreter.JuliaFrameCode
-JuliaInterpreter.JuliaProgramCounter
+JuliaInterpreter.Frame
+JuliaInterpreter.FrameCode
+JuliaInterpreter.FrameData
+JuliaInterpreter.FrameInstance
 JuliaInterpreter.BreakpointState
 JuliaInterpreter.BreakpointRef
 ```
@@ -69,11 +80,12 @@ JuliaInterpreter.compiled_methods
 
 ```@docs
 JuliaInterpreter.@lookup
-JuliaInterpreter.iswrappercall
+JuliaInterpreter.is_wrapper_call
 JuliaInterpreter.is_doc_expr
 JuliaInterpreter.is_global_ref
+CodeTracking.whereis
+JuliaInterpreter.linenumber
 JuliaInterpreter.statementnumber
 JuliaInterpreter.Variable
 JuliaInterpreter.locals
-CodeTracking.whereis
 ```

docs/src/internals.md

@@ -9,35 +9,25 @@ let's build a frame:
 
 ```julia
 julia> frame = JuliaInterpreter.enter_call(summer, A)
-JuliaStackFrame(JuliaInterpreter.JuliaFrameCode(summer(A::AbstractArray{T,N} where N) where T in Main at REPL[1]:2, CodeInfo(
-1 ─       s = ($(QuoteNode(zero)))($(Expr(:static_parameter, 1)))
-│   %2  = A
-│         #temp# = ($(QuoteNode(iterate)))(%2)
-│   %4  = ($(QuoteNode(===)))(#temp#, nothing)
-│   %5  = ($(QuoteNode(not_int)))(%4)
-└──       goto #4 if not %5
-2 ┄ %7  = #temp#
-│         a = ($(QuoteNode(getfield)))(%7, 1)
-│   %9  = ($(QuoteNode(getfield)))(%7, 2)
-│         s = ($(QuoteNode(+)))(s, a)
-│         #temp# = ($(QuoteNode(iterate)))(%2, %9)
-│   %12 = ($(QuoteNode(===)))(#temp#, nothing)
-│   %13 = ($(QuoteNode(not_int)))(%12)
-└──       goto #4 if not %13
-3 ─       goto #2
-4 ┄       return s
-), Core.TypeMapEntry[#undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef], BitSet([2, 4, 5, 7, 9, 12, 13]), false, false, true), Union{Nothing, Some{Any}}[Some(summer), Some([1, 2, 5]), nothing, nothing, nothing], Any[#undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef, #undef], Any[Int64], Int64[], Base.RefValue{Any}(nothing), Base.RefValue{JuliaInterpreter.JuliaProgramCounter}(JuliaProgramCounter(1)), Dict{Symbol,Int64}(), Any[])
+Frame for summer(A::AbstractArray{T,N} where N) where T in Main at REPL[2]:2
+   1* 2  1 ─       s = (zero)($(Expr(:static_parameter, 1)))
+   2  3  │   %2  = A
+   3  3  │         #temp# = (iterate)(%2)
+⋮
+A = [1, 2, 5]
+T = Int64
 ```
 
-This is a [`JuliaInterpreter.JuliaStackFrame`](@ref). The `CodeInfo` is the most prominent part of this display,
-and extractable as `code = frame.code.code`. (It's a slightly modified form of one returned by `@code_lowered`,
+This is a [`Frame`](@ref). Only a portion of the `CodeInfo` is shown, a small region surrounding
+the current statement (marked with `*` or in yellow text). The full `CodeInfo` can be extracted
+as `code = frame.framecode.src`. (It's a slightly modified form of one returned by `@code_lowered`,
 in that it has been processed by [`JuliaInterpreter.optimize!`](@ref) to speed up run-time execution.)
 
-Much of the rest of the `frame` holds values needed for or generated by execution.
+`frame` has another field, `framedata`, that holds values needed for or generated by execution.
 The input arguments are in `locals`:
 
 ```julia
-julia> frame.locals
+julia> frame.framedata.locals
 5-element Array{Union{Nothing, Some{Any}},1}:
  Some(summer)
  Some([1, 2, 5])
@@ -49,10 +39,10 @@ julia> frame.locals
 These correspond to the `code.slotnames`; the first is the `#self#` argument and the second
 is the input array. The remaining local variables (e.g., `s` and `a`), have not yet been assigned---we've
 only built the frame, but we haven't yet begun to execute it.
-The static parameter, `T`, is stored in `frame.sparams`:
+The static parameter, `T`, is stored in `frame.framedata.sparams`:
 
 ```julia
-julia> frame.sparams
+julia> frame.framedata.sparams
 1-element Array{Any,1}:
  Int64
 ```
@@ -62,7 +52,7 @@ The `Expr(:static_parameter, 1)` statement refers to this value.
 The other main storage is for the generated SSA values:
 
 ```julia
-julia> frame.ssavalues
+julia> frame.framedata.ssavalues
 16-element Array{Any,1}:
  #undef
  #undef
@@ -88,32 +78,26 @@ The other main entity is the so-called [program counter](https://en.wikipedia.or
 which just indicates the next statement to be executed:
 
 ```julia
-julia> frame.pc[]
-JuliaProgramCounter(1)
+julia> frame.pc
+1
 ```
 
-This is stored as a `Ref` so that it can be updated as execution progresses.
-
-Let's try executing the first statement. So that we can recurse into calls (e.g., `iterate`, `+`, etc.,),
-we'll create a [stack](https://en.wikipedia.org/wiki/Call_stack) of frames and then run the first statement:
+Let's try executing the first statement:
 
 ```julia
-julia> stack = JuliaInterpreter.JuliaStackFrame[]
-0-element Array{JuliaStackFrame,1}
-
-julia> JuliaInterpreter.step_expr!(stack, frame)
-JuliaProgramCounter(2)
+julia> JuliaInterpreter.step_expr!(frame)
+2
 ```
 
 This indicates that it ran statement 1 and is prepared to run statement 2.
 (It's worth noting that the first line included a `call` to `zero`, so behind the scenes
-JuliaInterpreter pushed this frame onto `stack`, created a new frame for `zero`,
-executed all the statements, and then popped the stack.)
+JuliaInterpreter created a new frame for `zero`, executed all the statements, and then popped
+back to `frame`.)
 Since the first statement is an assignment of a local variable, let's check the
 locals again:
 
 ```julia
-julia> frame.locals
+julia> frame.framedata.locals
 5-element Array{Union{Nothing, Some{Any}},1}:
  Some(summer)
  Some([1, 2, 5])
@@ -128,10 +112,10 @@ The next statement just retrieves one of the slots (the input argument `A`) and
 it in an SSA value:
 
 ```julia
-julia> JuliaInterpreter.step_expr!(stack, frame)
-JuliaProgramCounter(3)
+julia> JuliaInterpreter.step_expr!(frame)
+3
 
-julia> frame.ssavalues
+julia> frame.framedata.ssavalues
 16-element Array{Any,1}:
  #undef
     [1, 2, 5]
@@ -152,9 +136,9 @@ julia> frame.ssavalues
 ```
 
 One can easily continue this until execution completes, which is indicated when `step_expr!`
-returns `nothing`. Alternatively, use the higher-level `JuliaInterpreter.finish!(stack, frame)`
+returns `nothing`. Alternatively, use the higher-level `JuliaInterpreter.finish!(frame)`
 to step through the entire frame,
-or `JuliaInterpreter.finish_and_return!(stack, frame)` to also obtain the return value.
+or `JuliaInterpreter.finish_and_return!(frame)` to also obtain the return value.
 
 ## More complex expressions
 
@@ -171,7 +155,7 @@ ex = quote
 end
 
 frame = JuliaInterpreter.prepare_thunk(Main, ex)
-JuliaInterpreter.finish_and_return!(JuliaStackFrame[], frame)
+JuliaInterpreter.finish_and_return!(frame)
 
 # output
 
@@ -196,7 +180,7 @@ Here's a demonstration of the problem:
 ```julia
 ex = :(map(x->x^2, [1, 2, 3]))
 frame = JuliaInterpreter.prepare_thunk(Main, ex)
-julia> JuliaInterpreter.finish_and_return!(JuliaStackFrame[], frame)
+julia> JuliaInterpreter.finish_and_return!(frame)
 ERROR: this frame needs to be run a top level
 ```
 
@@ -235,7 +219,7 @@ function" for this type, equivalent to `(##17#18)(x) = x^2`.
 In some cases one can fix this simply by indicating that we want to run this frame at top level:
 
 ```julia
-julia> JuliaInterpreter.finish_and_return!(JuliaStackFrame[], frame, true)
+julia> JuliaInterpreter.finish_and_return!(frame, true)
 3-element Array{Int64,1}:
  1
  4
@@ -247,11 +231,10 @@ for more complex situations where there may be nested calls of new methods):
 
 ```julia
 modexs, _ = JuliaInterpreter.split_expressions(Main, ex)
-stack = JuliaStackFrame[]
 for (mod, e) in modexs
     frame = JuliaInterpreter.prepare_thunk(mod, e)
     while true
-        JuliaInterpreter.through_methoddef_or_done!(stack, frame) === nothing && break
+        JuliaInterpreter.through_methoddef_or_done!(frame) === nothing && break
     end
     JuliaInterpreter.get_return(frame)
 end

src/JuliaInterpreter.jl

@@ -12,8 +12,8 @@ using Random.DSFMT
 using InteractiveUtils
 using CodeTracking
 
-export @interpret, Compiled, JuliaStackFrame,
-       Breakpoints, breakpoint, @breakpoint, breakpoints, enable, disable, remove
+export @interpret, Compiled, Frame, root, leaf,
+       BreakpointRef, breakpoint, @breakpoint, breakpoints, enable, disable, remove
 
 module CompiledCalls
 # This module is for handling intrinsics that must be compiled (llvmcall)
@@ -26,6 +26,7 @@ include("localmethtable.jl")
 include("interpret.jl")
 include("builtins-julia$(Int(VERSION.major)).$(Int(VERSION.minor)).jl")
 include("optimize.jl")
+include("commands.jl")
 include("breakpoints.jl")
 
 function set_compiled_methods()

src/breakpoints.jl

@@ -21,37 +21,37 @@ function add_breakpoint(framecode, stmtidx)
     return bp
 end
 
-function shouldbreak(frame, pc=frame.pc[])
-    idx = convert(Int, pc)
-    isassigned(frame.code.breakpoints, idx) || return false
-    bp = frame.code.breakpoints[idx]
+function shouldbreak(frame::Frame, pc::Int)
+    bps = frame.framecode.breakpoints
+    isassigned(bps, pc) || return false
+    bp = bps[pc]
     bp.isactive || return false
     return Base.invokelatest(bp.condition, frame)::Bool
 end
 
-function prepare_slotfunction(framecode::JuliaFrameCode, body::Union{Symbol,Expr})
+function prepare_slotfunction(framecode::FrameCode, body::Union{Symbol,Expr})
     ismeth = framecode.scope isa Method
     uslotnames = Set{Symbol}()
     slotnames  = Symbol[]
-    for name in framecode.code.slotnames
+    for name in framecode.src.slotnames
         if name ∉ uslotnames
             push!(slotnames, name)
             push!(uslotnames, name)
         end
     end
-    assignments = Expr[]
-    framename = gensym("frame")
+    framename, dataname = gensym("frame"), gensym("data")
+    assignments = Expr[:($dataname = $framename.framedata)]
     default = Unassigned()
     for i = 1:length(slotnames)
-        slotname = framecode.code.slotnames[i]
+        slotname = framecode.src.slotnames[i]
         qslotname = QuoteNode(slotname)
-        getexpr = :(something($framename.locals[$framename.last_reference[$qslotname]]))
-        push!(assignments, Expr(:(=), slotname, :(haskey($framename.last_reference, $qslotname) ? $getexpr : $default)))
+        getexpr = :(something($dataname.locals[$dataname.last_reference[$qslotname]]))
+        push!(assignments, Expr(:(=), slotname, :(haskey($dataname.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])))
+            push!(assignments, Expr(:(=), syms[i], :($dataname.sparams[$i])))
         end
     end
     funcname = ismeth ? gensym("slotfunction") : gensym(Symbol(framecode.scope.name, "_slotfunction"))
@@ -62,8 +62,8 @@ const Condition = Union{Nothing,Expr,Tuple{Module,Expr}}
 _unpack(condition) = isa(condition, Expr) ? (Main, condition) : condition
 
 ## The fundamental implementations of breakpoint-setting
-function breakpoint!(framecode::JuliaFrameCode, pc, condition::Condition=nothing)
-    stmtidx = convert(Int, pc)
+function breakpoint!(framecode::FrameCode, pc, condition::Condition=nothing)
+    stmtidx = pc
     if condition === nothing
         framecode.breakpoints[stmtidx] = BreakpointState()
     else
@@ -73,8 +73,8 @@ function breakpoint!(framecode::JuliaFrameCode, pc, condition::Condition=nothing
     end
     return add_breakpoint(framecode, stmtidx)
 end
-breakpoint!(frame::JuliaStackFrame, pc=frame.pc[], condition::Condition=nothing) =
-    breakpoint!(frame.code, pc, condition)
+breakpoint!(frame::Frame, pc=frame.pc, condition::Condition=nothing) =
+    breakpoint!(frame.framecode, pc, condition)
 
 """
     enable(bp::BreakpointRef)