Add RTCallInfo for runtime calls

The list of call sites serves two purposes:

- it gives you options to descend into
- it summarizes the calls made by your function

Given the second purpose, I've sometimes been confused by the absence
of an entry for the "worst" of all cases, runtime dispatch. This seems
particularly accute for #345, but may have value even when examining
the CodeInfo/IRCode.

src/Cthulhu.jl

@@ -589,6 +589,11 @@ function _descend(term::AbstractTerminal, interp::AbstractInterpreter, curs::Abs
                 """
                 additional_descend(get_mi(info)::MethodInstance)
                 continue
+            elseif info isa RTCallInfo
+                @info """
+                This is a runtime call. You cannot descend into it.
+                """
+                @goto show_menu
             end
 
             # recurse

src/callsite.jl

@@ -33,6 +33,15 @@ struct LimitedCallInfo <: WrappedCallInfo
     wrapped::CallInfo
 end
 
+# Runtime CallInfo
+struct RTCallInfo <: CallInfo
+    f
+    argtyps
+    rt
+end
+get_mi(ci::RTCallInfo) = nothing
+get_effects(ci::RTCallInfo) = Effects()
+
 # uncached callsite, we can't recurse into this call
 struct UncachedCallInfo <: WrappedCallInfo
     wrapped::CallInfo
@@ -309,6 +318,8 @@ function show_callinfo(limiter, ci::Union{MultiCallInfo, FailedCallInfo, Generat
     __show_limited(limiter, name::String, tt, get_rt(ci), get_effects(ci))
 end
 
+show_callinfo(limiter, ci::RTCallInfo) = __show_limited(limiter, "$(ci.f)", ci.argtyps, get_rt(ci), get_effects(ci))
+
 function show_callinfo(limiter, pci::PureCallInfo)
     ft, tt... = pci.argtypes
     f = CC.singleton_type(ft)
@@ -366,6 +377,11 @@ function print_callsite_info(limiter::IO, info::Union{MultiCallInfo, FailedCallI
     show_callinfo(limiter, info)
 end
 
+function print_callsite_info(limiter::IO, info::RTCallInfo)
+    print(limiter, "RT call ")
+    show_callinfo(limiter, info)
+end
+
 function print_callsite_info(limiter::IO, info::TaskCallInfo)
     print(limiter, "task < ")
     show_callinfo(limiter, info.ci)

src/reflection.jl

@@ -32,28 +32,26 @@ function find_callsites(interp::AbstractInterpreter, CI::Union{Core.CodeInfo, IR
         callsite = nothing
         if stmt_infos !== nothing && is_call_expr(stmt, optimize)
             info = stmt_infos[id]
-            if info !== NoCallInfo()
-                rt = ignorelimited(argextype(SSAValue(id), CI, sptypes, slottypes))
-                # in unoptimized IR, there may be `slot = rhs` expressions, which `argextype` doesn't handle
-                # so extract rhs for such an case
-                local args = stmt.args
-                if !optimize
-                    args = (ignorelhs(stmt)::Expr).args
-                end
-                argtypes = mapany(function (@nospecialize(arg),)
-                                      t = argextype(arg, CI, sptypes, slottypes)
-                                      return ignorelimited(t)
-                                  end, args)
-                callinfos = process_info(interp, info, argtypes, rt, optimize)
-                isempty(callinfos) && continue
-                callsite = let
-                    if length(callinfos) == 1
-                        callinfo = callinfos[1]
-                    else
-                        callinfo = MultiCallInfo(argtypes_to_type(argtypes), rt, callinfos)
-                    end
-                    Callsite(id, callinfo, stmt.head)
+            rt = ignorelimited(argextype(SSAValue(id), CI, sptypes, slottypes))
+            # in unoptimized IR, there may be `slot = rhs` expressions, which `argextype` doesn't handle
+            # so extract rhs for such an case
+            local args = stmt.args
+            if !optimize
+                args = (ignorelhs(stmt)::Expr).args
+            end
+            argtypes = mapany(function (@nospecialize(arg),)
+                                    t = argextype(arg, CI, sptypes, slottypes)
+                                    return ignorelimited(t)
+                                end, args)
+            callinfos = process_info(interp, info, argtypes, rt, optimize)
+            isempty(callinfos) && continue
+            callsite = let
+                if length(callinfos) == 1
+                    callinfo = callinfos[1]
+                else
+                    callinfo = MultiCallInfo(argtypes_to_type(argtypes), rt, callinfos)
                 end
+                Callsite(id, callinfo, stmt.head)
             end
         end
 
@@ -211,7 +209,11 @@ function process_info(interp::AbstractInterpreter, @nospecialize(info::CCCallInf
             vmi = FailedCallInfo(sig, Union{})
         end
         return Any[ReturnTypeCallInfo(vmi)]
-    elseif info == NoCallInfo() || info === false
+    elseif info == NoCallInfo()
+        f = unwrapconst(argtypes[1])
+        isa(f, Core.Builtin) && return []
+        return [RTCallInfo(f, argtypes[2:end], rt)]
+    elseif info === false
         return []
     else
         @eval Main begin

test/test_terminal.jl

@@ -204,8 +204,9 @@ end
                 Base.text_colors[Base.error_color()]
             end
             @test occursin("$(warncolor)%\e[39m2 = call → fmulti(::Any)::Union{Float32, Int64}", lines)
+            write(in, keydict[:down])
             write(in, keydict[:enter])
-            lines = cread1(out)
+            lines = cread(out)
             @test occursin("%2 = fmulti(::Int32)::Union{Float32, $Int}", lines)
             @test occursin("%2 = fmulti(::Float32)::Union{Float32, $Int}", lines)
             @test occursin("%2 = fmulti(::Char)::Union{Float32, $Int}", lines)