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

Author: serenity4

Project.toml

@@ -1,14 +1,16 @@
 name = "LoweredCodeUtils"
 uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b"
-version = "3.3.0"
+version = "3.4.2"
 authors = ["Tim Holy <[email protected]>"]
 
 [deps]
 CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2"
+Compiler = "807dbc54-b67e-4c79-8afb-eafe4df6f2e1"
 JuliaInterpreter = "aa1ae85d-cabe-5617-a682-6adf51b2e16a"
 
 [compat]
 CodeTracking = "2"
+Compiler = "0.1"
 JuliaInterpreter = "0.10"
 julia = "1.10"
 

src/LoweredCodeUtils.jl

@@ -16,6 +16,7 @@ using JuliaInterpreter: SSAValue, SlotNumber, Frame, Interpreter, RecursiveInter
 using JuliaInterpreter: codelocation, is_global_ref, is_global_ref_egal, is_quotenode_egal, is_return,
                         lookup, lookup_return, linetable, moduleof, next_until!, nstatements, pc_expr,
                         step_expr!, whichtt, extract_method_table
+using Compiler: Compiler as CC
 
 include("packagedef.jl")
 

src/codeedges.jl

@@ -106,25 +106,25 @@ function print_with_code(preprint, postprint, io::IO, src::CodeInfo)
     used = BitSet()
     cfg = compute_basic_blocks(src.code)
     for stmt in src.code
-        Core.Compiler.scan_ssa_use!(push!, used, stmt)
+        CC.scan_ssa_use!(push!, used, stmt)
     end
     @static if isdefined(Base, :__has_internal_change) && Base.__has_internal_change(v"1.12-alpha", :printcodeinfocalls)
         sptypes = let parent = src.parent
             parent isa MethodInstance ?
-                Core.Compiler.sptypes_from_meth_instance(parent) :
-                Core.Compiler.EMPTY_SPTYPES
+                CC.sptypes_from_meth_instance(parent) :
+                CC.EMPTY_SPTYPES
         end
     end
-    line_info_preprinter = Base.IRShow.lineinfo_disabled
-    line_info_postprinter = Base.IRShow.default_expr_type_printer
+    line_info_preprinter = IRShow.lineinfo_disabled
+    line_info_postprinter = IRShow.default_expr_type_printer
     preprint(io)
     bb_idx_prev = bb_idx = 1
     for idx = 1:length(src.code)
         preprint(io, idx)
         @static if isdefined(Base, :__has_internal_change) && Base.__has_internal_change(v"1.12-alpha", :printcodeinfocalls)
-            bb_idx = Base.IRShow.show_ir_stmt(io, src, idx, line_info_preprinter, line_info_postprinter, sptypes, used, cfg, bb_idx)
+            bb_idx = IRShow.show_ir_stmt(io, src, idx, line_info_preprinter, line_info_postprinter, sptypes, used, cfg, bb_idx)
         else
-            bb_idx = Base.IRShow.show_ir_stmt(io, src, idx, line_info_preprinter, line_info_postprinter, used, cfg, bb_idx)
+            bb_idx = IRShow.show_ir_stmt(io, src, idx, line_info_preprinter, line_info_postprinter, used, cfg, bb_idx)
         end
         postprint(io, idx, bb_idx != bb_idx_prev)
         bb_idx_prev = bb_idx
@@ -760,8 +760,6 @@ end
 
 ## Add control-flow
 
-using Core: CodeInfo
-using Core.Compiler: CFG, BasicBlock, compute_basic_blocks
 
 # The goal of this function is to request concretization of the minimal necessary control
 # flow to evaluate statements whose concretization have already been requested.
@@ -1047,7 +1045,7 @@ function JuliaInterpreter.get_return(interp::SelectiveInterpreter, frame::Frame)
     node = pc_expr(frame, pc)
     if is_return(node)
         if interp.isrequired[pc]
-            return lookup_return(frame, node)
+            return lookup_return(interp.inner, frame, node)
         end
     else
         if isassigned(frame.framedata.ssavalues, pc)

src/domtree.jl

@@ -5,7 +5,6 @@
 
 # A few items needed to be added:
 
-using Core.Compiler: BasicBlock
 import Base: length, copy, copy!
 
 # END additions

src/packagedef.jl

@@ -5,11 +5,20 @@ 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 .CC:
+    BasicBlock, CFG,
+    compute_basic_blocks, construct_domtree, construct_postdomtree,
+    nearest_common_dominator, postdominates
+
+@static if isdefined(CC, :IRShow)
+    using .CC: IRShow
+else
+    using Base: IRShow
+end
+
 using Base.Meta: isexpr
 
-const SSAValues = Union{Core.Compiler.SSAValue, JuliaInterpreter.SSAValue}
+const SSAValues = Union{Core.IR.SSAValue, JuliaInterpreter.SSAValue}
 
 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)

src/utils.jl

@@ -1,15 +1,15 @@
-const AnySSAValue = Union{Core.Compiler.SSAValue,JuliaInterpreter.SSAValue}
-const AnySlotNumber = Union{Core.Compiler.SlotNumber,JuliaInterpreter.SlotNumber}
+const AnySSAValue = Union{Core.IR.SSAValue,JuliaInterpreter.SSAValue}
+const AnySlotNumber = Union{Core.IR.SlotNumber,JuliaInterpreter.SlotNumber}
 
 # to circumvent https://github.com/JuliaLang/julia/issues/37342, we inline these `isa`
 # condition checks at surface AST level
 # https://github.com/JuliaLang/julia/pull/38905 will get rid of the need of these hacks
 macro isssa(stmt)
-    :($(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(Core.Compiler, :SSAValue))) ||
+    :($(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(Core.IR, :SSAValue))) ||
       $(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(JuliaInterpreter, :SSAValue))))
 end
 macro issslotnum(stmt)
-    :($(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(Core.Compiler, :SlotNumber))) ||
+    :($(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(Core.IR, :SlotNumber))) ||
       $(GlobalRef(Core, :isa))($(esc(stmt)), $(GlobalRef(JuliaInterpreter, :SlotNumber))))
 end
 
@@ -211,8 +211,8 @@ end
 
 showempty(list) = isempty(list) ? '∅' : list
 
-# Smooth the transition between Core.Compiler and Base
-rng(bb::Core.Compiler.BasicBlock) = (r = bb.stmts; return Core.Compiler.first(r):Core.Compiler.last(r))
+# Smooth the transition between CC and Base (not requried for v1.12 and above)
+rng(bb::BasicBlock) = (r = bb.stmts; return CC.first(r):CC.last(r))
 
 function pushall!(dest, src)
     for item in src
@@ -224,7 +224,7 @@ end
 # computes strongly connected components of a control flow graph `cfg`
 # NOTE adapted from https://github.com/JuliaGraphs/Graphs.jl/blob/5878e7be4d68b2a1c179d1367aea670db115ebb5/src/connectivity.jl#L265-L357
 # since to load an entire Graphs.jl is a bit cost-ineffective in terms of a trade-off of latency vs. maintainability
-function strongly_connected_components(g::Core.Compiler.CFG)
+function strongly_connected_components(g::CFG)
     T = Int
     zero_t = zero(T)
     one_t = one(T)
@@ -322,12 +322,12 @@ function strongly_connected_components(g::Core.Compiler.CFG)
 end
 
 # compatibility with Graphs.jl interfaces
-@inline nv(cfg::Core.Compiler.CFG) = length(cfg.blocks)
-@inline vertices(cfg::Core.Compiler.CFG) = 1:nv(cfg)
-@inline outneighbors(cfg::Core.Compiler.CFG, v) = cfg.blocks[v].succs
+@inline nv(cfg::CFG) = length(cfg.blocks)
+@inline vertices(cfg::CFG) = 1:nv(cfg)
+@inline outneighbors(cfg::CFG, v) = cfg.blocks[v].succs
 
 # using Graphs: SimpleDiGraph, add_edge!, strongly_connected_components as oracle_scc
-# function cfg_to_sdg(cfg::Core.Compiler.CFG)
+# function cfg_to_sdg(cfg::CFG)
 #     g = SimpleDiGraph(length(cfg.blocks))
 #     for (v, block) in enumerate(cfg.blocks)
 #         for succ in block.succs

test/codeedges.jl

@@ -2,6 +2,7 @@ module codeedges
 
 using LoweredCodeUtils
 using LoweredCodeUtils.JuliaInterpreter
+using LoweredCodeUtils: CC
 using LoweredCodeUtils: callee_matches, istypedef, exclude_named_typedefs
 using JuliaInterpreter: is_global_ref, is_quotenode
 using Test
@@ -324,7 +325,7 @@ module ModSelective end
     src = frame.framecode.src
     edges = CodeEdges(ModEval, src)
     isrequired = minimal_evaluation(@nospecialize(stmt)->(LoweredCodeUtils.ismethod3(stmt),false), src, edges; norequire=exclude_named_typedefs(src, edges))  # initially mark only the constructor
-    bbs = Core.Compiler.compute_basic_blocks(src.code)
+    bbs = CC.compute_basic_blocks(src.code)
     for (iblock, block) in enumerate(bbs.blocks)
         r = LoweredCodeUtils.rng(block)
         if iblock == length(bbs.blocks)

test/signatures.jl

@@ -323,7 +323,7 @@ bodymethtest5(x, y=Dict(1=>2)) = 5
     methoddefs!(signatures, frame; define=false)
     @test !isempty(signatures)
 
-    # Inner methods in structs. Comes up in, e.g., Core.Compiler.Params.
+    # Inner methods in structs. Comes up in, e.g., CC.Params.
     # The body of CustomMS is an SSAValue.
     ex = quote
         struct MyStructWithMeth