Merge branch 'master' of github.com:JuliaDebug/LoweredCodeUtils.jl into support-external-methodtables

Author: serenity4

Project.toml

@@ -1,7 +1,7 @@
 name = "LoweredCodeUtils"
 uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b"
 authors = ["Tim Holy <[email protected]>"]
-version = "3.1.0"
+version = "3.2.1"
 
 [deps]
 JuliaInterpreter = "aa1ae85d-cabe-5617-a682-6adf51b2e16a"

src/LoweredCodeUtils.jl

@@ -11,7 +11,7 @@ module LoweredCodeUtils
 
 using JuliaInterpreter
 using JuliaInterpreter: SSAValue, SlotNumber, Frame
-using JuliaInterpreter: @lookup, moduleof, pc_expr, step_expr!, is_global_ref, is_quotenode_egal, whichtt,
+using JuliaInterpreter: @lookup, moduleof, pc_expr, step_expr!, is_global_ref, is_global_ref_egal, is_quotenode_egal, whichtt,
                         next_until!, finish_and_return!, get_return, nstatements, codelocation, linetable,
                         is_return, lookup_return, extract_method_table
 

src/codeedges.jl

@@ -163,8 +163,10 @@ function postprint_linelinks(io::IO, idx::Int, src::CodeInfo, cl::CodeLinks, bbc
     printstyled(io, bbchanged ? " " : "│", color=:light_black)
     printstyled(io, "             # ", color=:yellow)
     stmt = src.code[idx]
-    if is_assignment_like(stmt)
-        lhs = normalize_defsig(stmt.args[1], cl.thismod)
+    lhs_rhs = get_lhs_rhs(stmt)
+    if lhs_rhs !== nothing
+        lhs, _ = lhs_rhs
+        lhs = normalize_defsig(lhs, cl.thismod)
         if @issslotnum(lhs)
             # id = lhs.id
             # preds, succs = cl.slotpreds[id], cl.slotsuccs[id]
@@ -190,38 +192,58 @@ function namedkeys(cl::CodeLinks)
     return ukeys
 end
 
-is_assignment_like(stmt::Expr) = isexpr(stmt, :(=)) || (isexpr(stmt, :const) && length(stmt.args) == 2)
-is_assignment_like(@nospecialize stmt) = false
+# Required by Revise, but otherwise deprecated
+# The depwarn is currently disabled because Revise's tests check for empty warning logs
+function is_assignment_like(@nospecialize stmt)
+    # Base.depwarn("is_assignment_like is deprecated, switch to `LoweredCodeUtils.get_lhs_rhs`", :is_assignment_like)
+    return isexpr(stmt, :(=)) || isexpr(stmt, :const, 2)
+end
+
+function get_lhs_rhs(@nospecialize stmt)
+    if isexpr(stmt, :(=))
+        return Pair{Any,Any}(stmt.args[1], stmt.args[2])
+    elseif isexpr(stmt, :const) && length(stmt.args) == 2
+        return Pair{Any,Any}(stmt.args[1], stmt.args[2])
+    elseif isexpr(stmt, :call) && length(stmt.args) == 4
+        f = stmt.args[1]
+        if is_global_ref_egal(f, :setglobal!, Core.setglobal!)
+            mod = stmt.args[2]
+            mod isa Module || return nothing
+            name = stmt.args[3]
+            if name isa QuoteNode
+                name = name.value
+            end
+            name isa Symbol || return nothing
+            lhs = GlobalRef(mod, name)
+            return Pair{Any,Any}(lhs, stmt.args[4])
+        end
+    end
+    return nothing
+end
 
 function direct_links!(cl::CodeLinks, src::CodeInfo)
     # Utility for when a stmt itself contains a CodeInfo
     function add_inner!(cl::CodeLinks, icl::CodeLinks, idx)
         for (name, _) in icl.nameassigns
-            assigns = get(cl.nameassigns, name, nothing)
-            if assigns === nothing
-                cl.nameassigns[name] = assigns = Int[]
-            end
+            assigns = get!(Vector{Int}, cl.nameassigns, name)
             push!(assigns, idx)
         end
         for (name, _) in icl.namesuccs
-            succs = get(cl.namesuccs, name, nothing)
-            if succs === nothing
-                cl.namesuccs[name] = succs = Links()
-            end
+            succs = get!(Links, cl.namesuccs, name)
             push!(succs.ssas, idx)
         end
     end
 
     P = Pair{Union{SSAValue,SlotNumber,GlobalRef},Links}
 
     for (i, stmt) in enumerate(src.code)
-        if isexpr(stmt, :thunk) && isa(stmt.args[1], CodeInfo)
-            icl = CodeLinks(cl.thismod, stmt.args[1])
+        if isexpr(stmt, :thunk) && (arg1 = stmt.args[1]; arg1 isa CodeInfo)
+            icl = CodeLinks(cl.thismod, arg1)
             add_inner!(cl, icl, i)
             continue
-        elseif isa(stmt, Expr) && stmt.head ∈ trackedheads
-            if stmt.head === :method && length(stmt.args) === 3 && isa(stmt.args[3], CodeInfo)
-                icl = CodeLinks(cl.thismod, stmt.args[3])
+        elseif isexpr(stmt, :method)
+            if length(stmt.args) === 3 && (arg3 = stmt.args[3]; arg3 isa CodeInfo)
+                icl = CodeLinks(cl.thismod, arg3)
                 add_inner!(cl, icl, i)
             end
             name = stmt.args[1]
@@ -234,10 +256,7 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
                     cl.nameassigns[name] = assign = Int[]
                 end
                 push!(assign, i)
-                targetstore = get(cl.namepreds, name, nothing)
-                if targetstore === nothing
-                    cl.namepreds[name] = targetstore = Links()
-                end
+                targetstore = get!(Links, cl.namepreds, name)
                 target = P(name, targetstore)
                 add_links!(target, stmt, cl)
             elseif name in (nothing, false)
@@ -247,10 +266,10 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
             end
             rhs = stmt
             target = P(SSAValue(i), cl.ssapreds[i])
-        elseif is_assignment_like(stmt)
+        elseif (lhs_rhs = get_lhs_rhs(stmt); lhs_rhs !== nothing)
             # An assignment
             stmt = stmt::Expr
-            lhs, rhs = stmt.args[1], stmt.args[2]
+            lhs, rhs = lhs_rhs
             if @issslotnum(lhs)
                 lhs = lhs::AnySlotNumber
                 id = lhs.id
@@ -260,10 +279,7 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
                 if isa(lhs, Symbol)
                     lhs = GlobalRef(cl.thismod, lhs)
                 end
-                targetstore = get(cl.namepreds, lhs, nothing)
-                if targetstore === nothing
-                    cl.namepreds[lhs] = targetstore = Links()
-                end
+                targetstore = get!(Links, cl.namepreds, lhs)
                 target = P(lhs, targetstore)
                 assign = get(cl.nameassigns, lhs, nothing)
                 if assign === nothing
@@ -299,23 +315,35 @@ function add_links!(target::Pair{Union{SSAValue,SlotNumber,GlobalRef},Links}, @n
             stmt = GlobalRef(cl.thismod, stmt)
         end
         push!(targetstore, stmt)
-        namestore = get(cl.namesuccs, stmt, nothing)
-        if namestore === nothing
-            cl.namesuccs[stmt] = namestore = Links()
-        end
+        namestore = get!(Links, cl.namesuccs, stmt)
         push!(namestore, targetid)
-    elseif isa(stmt, Expr) && stmt.head !== :copyast
-        stmt = stmt::Expr
-        arng = 1:length(stmt.args)
-        if stmt.head === :call
-            f = stmt.args[1]
-            if !@isssa(f) && !@issslotnum(f)
-                # Avoid putting named callees on the namestore
-                arng = 2:length(stmt.args)
+    elseif isa(stmt, Expr)
+        if stmt.head === :globaldecl
+            for i = 1:length(stmt.args)
+                a = stmt.args[i]
+                if a isa GlobalRef
+                    namestore = get!(Links, cl.namepreds, a) # TODO should this information be tracked in the separate `cl.namedecls` store?
+                    push!(namestore, targetid)
+                    if targetid isa SSAValue
+                        push!(namestore, SSAValue(targetid.id+1)) # +1 for :latestworld
+                    end
+                else
+                    add_links!(target, a, cl)
+                end
+            end
+        elseif stmt.head !== :copyast
+            stmt = stmt::Expr
+            arng = 1:length(stmt.args)
+            if stmt.head === :call
+                f = stmt.args[1]
+                if !@isssa(f) && !@issslotnum(f)
+                    # Avoid putting named callees on the namestore
+                    arng = 2:length(stmt.args)
+                end
+            end
+            for i in arng
+                add_links!(target, stmt.args[i], cl)
             end
-        end
-        for i in arng
-            add_links!(target, stmt.args[i], cl)
         end
     elseif stmt isa Core.GotoIfNot
         add_links!(target, stmt.cond, cl)
@@ -362,7 +390,6 @@ struct Variable
     preds::Vector{Int}
     succs::Vector{Int}
 end
-Variable() = Variable(Int[], Int[], Int[])
 
 function Base.show(io::IO, v::Variable)
     print(io, "assigned on ", showempty(v.assigned))
@@ -423,9 +450,9 @@ function CodeEdges(src::CodeInfo, cl::CodeLinks)
     emptylist = Int[]
     for (i, stmt) in enumerate(src.code)
         # Identify line predecents for slots and named variables
-        if is_assignment_like(stmt)
+        if (lhs_rhs = get_lhs_rhs(stmt); lhs_rhs !== nothing)
             stmt = stmt::Expr
-            lhs = stmt.args[1]
+            lhs, _ = lhs_rhs
             # Mark predecessors and successors of this line by following ssas & named assignments
             if @issslotnum(lhs)
                 lhs = lhs::AnySlotNumber
@@ -611,7 +638,7 @@ function exclude_named_typedefs(src::CodeInfo, edges::CodeEdges)
     i = 1
     nstmts = length(src.code)
     while i <= nstmts
-        stmt = rhs(src.code[i])
+        stmt = getrhs(src.code[i])
         if istypedef(stmt) && !isanonymous_typedef(stmt::Expr)
             r = typedef_range(src, i)
             pushall!(norequire, r)
@@ -715,10 +742,17 @@ function add_succs!(isrequired, idx, edges::CodeEdges, succs, norequire)
     end
     return chngd
 end
-function add_obj!(isrequired, objs, obj, edges::CodeEdges, norequire)
+function add_obj!(isrequired, objs, obj::GlobalRef, edges::CodeEdges, norequire)
     chngd = false
+    for p in edges.byname[obj].preds
+        p ∈ norequire && continue
+        isrequired[p] && continue
+        isrequired[p] = true
+        chngd = true
+    end
     for d in edges.byname[obj].assigned
         d ∈ norequire && continue
+        isrequired[d] && continue
         isrequired[d] || add_preds!(isrequired, d, edges, norequire)
         isrequired[d] = true
         chngd = true
@@ -871,7 +905,7 @@ function find_typedefs(src::CodeInfo)
     i = 1
     nstmts = length(src.code)
     while i <= nstmts
-        stmt = rhs(src.code[i])
+        stmt = getrhs(src.code[i])
         if istypedef(stmt) && !isanonymous_typedef(stmt::Expr)
             stmt = stmt::Expr
             r = typedef_range(src, i)
@@ -972,8 +1006,8 @@ function add_inplace!(isrequired, src, edges, norequire)
                     for k in edges.preds[j]
                         isrequired[k] || continue
                         predstmt = src.code[k]
-                        if is_assignment_like(predstmt)
-                            lhs = predstmt.args[1]
+                        if (lhs_rhs = get_lhs_rhs(predstmt); lhs_rhs !== nothing)
+                            lhs, _ = lhs_rhs
                             if @issslotnum(lhs) && lhs.id == id
                                 changed |= mark_if_inplace(stmt, j)
                                 break
@@ -1056,7 +1090,7 @@ function print_with_code(io::IO, src::CodeInfo, isrequired::AbstractVector{Bool}
     preprint(::IO) = nothing
     preprint(io::IO, idx::Int) = (c = isrequired[idx]; printstyled(io, lpad(idx, nd), ' ', c ? "t " : "f "; color = c ? :cyan : :plain))
     postprint(::IO) = nothing
-    postprint(io::IO, idx::Int, bbchanged::Bool) = nothing
+    postprint(::IO, idx::Int, bbchanged::Bool) = nothing
 
     print_with_code(preprint, postprint, io, src)
 end

src/packagedef.jl

@@ -1,14 +1,17 @@
 Base.Experimental.@optlevel 1
 
-using Core: SimpleVector
-using Core.IR
+using Core: SimpleVector, MethodTable
+using Core.IR: CodeInfo, GotoIfNot, GotoNode, IR, MethodInstance, ReturnNode
+@static if isdefined(Core.IR, :EnterNode)
+    using Core.IR: EnterNode
+end
 using Core.Compiler: construct_domtree, construct_postdomtree, nearest_common_dominator,
     postdominates
 using Base.Meta: isexpr
 
 const SSAValues = Union{Core.Compiler.SSAValue, JuliaInterpreter.SSAValue}
 
-const trackedheads = (:method,)
+const trackedheads = (:method,)    # Revise uses this (for now), don't delete; also update test/hastrackedexpr if this list gets expanded
 const structdecls = (:_structtype, :_abstracttype, :_primitivetype)
 
 export signature, rename_framemethods!, methoddef!, methoddefs!, bodymethod

src/utils.jl

@@ -58,9 +58,9 @@ function callee_matches(f, mod, sym)
     return false
 end
 
-function rhs(stmt)
-    is_assignment_like(stmt) && return (stmt::Expr).args[2]
-    return stmt
+function getrhs(@nospecialize(stmt))
+    lhs_rhs = get_lhs_rhs(stmt)
+    return lhs_rhs === nothing ? stmt : lhs_rhs[2]
 end
 
 ismethod(frame::Frame)  = ismethod(pc_expr(frame))
@@ -107,7 +107,7 @@ function ismethod_with_name(src, stmt, target::AbstractString; reentrant::Bool=f
 end
 
 # anonymous function types are defined in a :thunk expr with a characteristic CodeInfo
-function isanonymous_typedef(stmt)
+function isanonymous_typedef(@nospecialize stmt)
     if isa(stmt, Expr)
         stmt.head === :thunk || return false
         stmt = stmt.args[1]
@@ -119,21 +119,22 @@ function isanonymous_typedef(stmt)
         isexpr(stmt, :call) || return false
         is_global_ref(stmt.args[1], Core, :_typebody!) || return false
         stmt = isa(stmt.args[3], Core.SSAValue) ? src.code[end-3] : src.code[end-2]
-        is_assignment_like(stmt) || return false
-        name = stmt.args[1]
-        if isa(name, GlobalRef)
-            name = name.name
+        lhs_rhs = get_lhs_rhs(stmt)
+        lhs_rhs === nothing && return false
+        lhs, _ = lhs_rhs
+        if isa(lhs, GlobalRef)
+            lhs = lhs.name
         else
-            isa(name, Symbol) || return false
+            isa(lhs, Symbol) || return false
         end
-        return startswith(String(name), "#")
+        return startswith(String(lhs), "#")
     end
     return false
 end
 
 function istypedef(stmt)
     isa(stmt, Expr) || return false
-    stmt = rhs(stmt)
+    stmt = getrhs(stmt)
     isa(stmt, Expr) || return false
     @static if all(s->isdefined(Core,s), structdecls)
         if stmt.head === :call
@@ -162,6 +163,7 @@ function typedef_range(src::CodeInfo, idx)
     istart = idx
     while istart >= 1
         isexpr(src.code[istart], :global) && break
+        isexpr(src.code[istart], :latestworld) && break
         istart -= 1
     end
     istart >= 1 || error("no initial :global found")
@@ -171,6 +173,7 @@ function typedef_range(src::CodeInfo, idx)
         stmt = src.code[iend]
         if isa(stmt, Expr)
             stmt.head === :global && break
+            stmt.head === :latestworld && break
             if stmt.head === :call
                 if (is_global_ref(stmt.args[1], Core, :_typebody!) || is_quotenode_egal(stmt.args[1], Core._typebody!))
                     have_typebody = true
@@ -179,7 +182,7 @@ function typedef_range(src::CodeInfo, idx)
                     # Advance to the type-assignment
                     while iend <= n
                         stmt = src.code[iend]
-                        is_assignment_like(stmt) && break
+                        get_lhs_rhs(stmt) !== nothing && break
                         iend += 1
                     end
                 end