#37623

Committed 16 Sep 2023 12:52PM UTC coverage: 86.162% (+1.2%) from 84.955%

Build # #37623

Build Type

push

local

Committed by

web-flow

Commit Message

Upgradeable Statistics stdlib (#46501)

Run Details

72491 of 84133 relevant lines covered (86.16%)

11642585.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

28.57

/stdlib/InteractiveUtils/src/codeview.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

# highlighting settings
const highlighting = Dict{Symbol, Bool}(
    :warntype => true,
    :llvm => true,
    :native => true,
)

const llstyle = Dict{Symbol, Tuple{Bool, Union{Symbol, Int}}}(
    :default     => (false, :normal), # e.g. comma, equal sign, unknown token
    :comment     => (false, :light_black),
    :label       => (false, :light_red),
    :instruction => ( true, :light_cyan),
    :type        => (false, :cyan),
    :number      => (false, :yellow),
    :bracket     => (false, :yellow),
    :variable    => (false, :normal), # e.g. variable, register
    :keyword     => (false, :light_magenta),
    :funcname    => (false, :light_yellow),
)

function printstyled_ll(io::IO, x, s::Symbol, trailing_spaces="")
    printstyled(io, x, bold=llstyle[s][1], color=llstyle[s][2])
    print(io, trailing_spaces)
end

# displaying type warnings

function warntype_type_printer(io::IO; @nospecialize(type), used::Bool, show_type::Bool=true, _...)
    (show_type && used) || return nothing
    str = "::$type"
    if !highlighting[:warntype]
        print(io, str)
    elseif type isa Union && is_expected_union(type)
        Base.emphasize(io, str, Base.warn_color()) # more mild user notification
    elseif type isa Type && (!Base.isdispatchelem(type) || type == Core.Box)
        Base.emphasize(io, str)
    else
        Base.printstyled(io, str, color=:cyan) # show the "good" type
    end
    return nothing
end

# True if one can be pretty certain that the compiler handles this union well,
# i.e. must be small with concrete types.
function is_expected_union(u::Union)
    Base.unionlen(u) < 4 || return false
    for x in Base.uniontypes(u)
        if !Base.isdispatchelem(x) || x == Core.Box
            return false
        end
    end
    return true
end

"""
    code_warntype([io::IO], f, types; debuginfo=:default)

Prints lowered and type-inferred ASTs for the methods matching the given generic function
and type signature to `io` which defaults to `stdout`. The ASTs are annotated in such a way
as to cause "non-leaf" types which may be problematic for performance to be emphasized
(if color is available, displayed in red). This serves as a warning of potential type instability.

Not all non-leaf types are particularly problematic for performance, and the performance
characteristics of a particular type is an implementation detail of the compiler.
`code_warntype` will err on the side of coloring types red if they might be a performance
concern, so some types may be colored red even if they do not impact performance.
Small unions of concrete types are usually not a concern, so these are highlighted in yellow.

Keyword argument `debuginfo` may be one of `:source` or `:none` (default), to specify the verbosity of code comments.

See [`@code_warntype`](@ref man-code-warntype) for more information.
"""
function code_warntype(io::IO, @nospecialize(f), @nospecialize(t=Base.default_tt(f));
                       debuginfo::Symbol=:default, optimize::Bool=false, kwargs...)
    debuginfo = Base.IRShow.debuginfo(debuginfo)
    lineprinter = Base.IRShow.__debuginfo[debuginfo]
    for (src, rettype) in code_typed(f, t; optimize, kwargs...)
        if !(src isa Core.CodeInfo)
            println(io, src)
            println(io, "  failed to infer")
            continue
        end
        lambda_io::IOContext = io
        p = src.parent
        nargs::Int = 0
        if p isa Core.MethodInstance
            println(io, p)
            print(io, "  from ")
            println(io, p.def)
            p.def isa Method && (nargs = p.def.nargs)
            if !isempty(p.sparam_vals)
                println(io, "Static Parameters")
                sig = p.def.sig
                warn_color = Base.warn_color() # more mild user notification
                for i = 1:length(p.sparam_vals)
                    sig = sig::UnionAll
                    name = sig.var.name
                    val = p.sparam_vals[i]
                    print_highlighted(io::IO, v::String, color::Symbol) =
                        if highlighting[:warntype]
                            Base.printstyled(io, v; color)
                        else
                            Base.print(io, v)
                        end
                    if val isa TypeVar
                        if val.lb === Union{}
                            print(io, "  ", name, " <: ")
                            print_highlighted(io, "$(val.ub)", warn_color)
                        elseif val.ub === Any
                            print(io, "  ", sig.var.name, " >: ")
                            print_highlighted(io, "$(val.lb)", warn_color)
                        else
                            print(io, "  ")
                            print_highlighted(io, "$(val.lb)", warn_color)
                            print(io, " <: ", sig.var.name, " <: ")
                            print_highlighted(io, "$(val.ub)", warn_color)
                        end
                    elseif val isa typeof(Vararg)
                        print(io, "  ", name, "::")
                        print_highlighted(io, "Int", warn_color)
                    else
                        print(io, "  ", sig.var.name, " = ")
                        print_highlighted(io, "$(val)", :cyan) # show the "good" type
                    end
                    println(io)
                    sig = sig.body
                end
            end
        end
        if src.slotnames !== nothing
            slotnames = Base.sourceinfo_slotnames(src)
            lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => slotnames)
            slottypes = src.slottypes
            nargs > 0 && println(io, "Arguments")
            for i = 1:length(slotnames)
                if i == nargs + 1
                    println(io, "Locals")
                end
                print(io, "  ", slotnames[i])
                if isa(slottypes, Vector{Any})
                    warntype_type_printer(io; type=slottypes[i], used=true)
                end
                println(io)
            end
        end
        print(io, "Body")
        warntype_type_printer(io; type=rettype, used=true)
        println(io)
        irshow_config = Base.IRShow.IRShowConfig(lineprinter(src), warntype_type_printer)
        Base.IRShow.show_ir(lambda_io, src, irshow_config)
        println(io)
    end
    nothing
end
code_warntype(args...; kwargs...) = (@nospecialize; code_warntype(stdout, args...; kwargs...))

using Base: CodegenParams

const GENERIC_SIG_WARNING = "; WARNING: This code may not match what actually runs.\n"
const OC_MISMATCH_WARNING =
"""
; WARNING: The pre-inferred opaque closure is not callable with the given arguments
;          and will error on dispatch with this signature.
"""

# Printing code representations in IR and assembly

function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrapper::Bool,
                        raw::Bool, dump_module::Bool, syntax::Symbol,
                        optimize::Bool, debuginfo::Symbol, binary::Bool,
                        params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
    ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
    if isa(f, Core.Builtin)
        throw(ArgumentError("argument is not a generic function"))
    end
    warning = ""
    # get the MethodInstance for the method match
    if !isa(f, Core.OpaqueClosure)
        world = Base.get_world_counter()
        match = Base._which(signature_type(f, t); world)
        mi = Core.Compiler.specialize_method(match)
        # TODO: use jl_is_cacheable_sig instead of isdispatchtuple
        isdispatchtuple(mi.specTypes) || (warning = GENERIC_SIG_WARNING)
    else
        world = UInt64(f.world)
        tt = Base.to_tuple_type(t)
        if Core.Compiler.is_source_inferred(f.source.source)
            # OC was constructed from inferred source. There's only one
            # specialization and we can't infer anything more precise either.
            world = f.source.primary_world
            mi = f.source.specializations::Core.MethodInstance
            Core.Compiler.hasintersect(typeof(f).parameters[1], tt) || (warning = OC_MISMATCH_WARNING)
        else
            mi = Core.Compiler.specialize_method(f.source, Tuple{typeof(f.captures), tt.parameters...}, Core.svec())
            actual = isdispatchtuple(mi.specTypes)
            isdispatchtuple(mi.specTypes) || (warning = GENERIC_SIG_WARNING)
        end
    end
    # get the code for it
    if debuginfo === :default
        debuginfo = :source
    elseif debuginfo !== :source && debuginfo !== :none
        throw(ArgumentError("'debuginfo' must be either :source or :none"))
    end
    if native
        if syntax !== :att && syntax !== :intel
            throw(ArgumentError("'syntax' must be either :intel or :att"))
        end
        if dump_module
            # we want module metadata, so use LLVM to generate assembly output
            str = _dump_function_native_assembly(mi, world, wrapper, syntax, debuginfo, binary, raw, params)
        else
            # if we don't want the module metadata, just disassemble what our JIT has
            str = _dump_function_native_disassembly(mi, world, wrapper, syntax, debuginfo, binary)
        end
    else
        str = _dump_function_llvm(mi, world, wrapper, !raw, dump_module, optimize, debuginfo, params)
    end
    str = warning * str
    return str
end

function _dump_function_native_disassembly(mi::Core.MethodInstance, world::UInt,
                                           wrapper::Bool, syntax::Symbol,
                                           debuginfo::Symbol, binary::Bool)
    str = @ccall jl_dump_method_asm(mi::Any, world::UInt, false::Bool, wrapper::Bool,
                                    syntax::Ptr{UInt8}, debuginfo::Ptr{UInt8},
                                    binary::Bool)::Ref{String}
    return str
end

struct LLVMFDump
    tsm::Ptr{Cvoid} # opaque
    f::Ptr{Cvoid} # opaque
end

function _dump_function_native_assembly(mi::Core.MethodInstance, world::UInt,
                                        wrapper::Bool, syntax::Symbol, debuginfo::Symbol,
                                        binary::Bool, raw::Bool, params::CodegenParams)
    llvmf_dump = Ref{LLVMFDump}()
    @ccall jl_get_llvmf_defn(llvmf_dump::Ptr{LLVMFDump},mi::Any, world::UInt, wrapper::Bool,
                             true::Bool, params::CodegenParams)::Cvoid
    llvmf_dump[].f == C_NULL && error("could not compile the specified method")
    str = @ccall jl_dump_function_asm(llvmf_dump::Ptr{LLVMFDump}, false::Bool,
                                      syntax::Ptr{UInt8}, debuginfo::Ptr{UInt8},
                                      binary::Bool, raw::Bool)::Ref{String}
    return str
end

function _dump_function_llvm(
        mi::Core.MethodInstance, world::UInt, wrapper::Bool,
        strip_ir_metadata::Bool, dump_module::Bool,
        optimize::Bool, debuginfo::Symbol,
        params::CodegenParams)
    llvmf_dump = Ref{LLVMFDump}()
    @ccall jl_get_llvmf_defn(llvmf_dump::Ptr{LLVMFDump}, mi::Any, world::UInt,
                             wrapper::Bool, optimize::Bool, params::CodegenParams)::Cvoid
    llvmf_dump[].f == C_NULL && error("could not compile the specified method")
    str = @ccall jl_dump_function_ir(llvmf_dump::Ptr{LLVMFDump}, strip_ir_metadata::Bool,
                                     dump_module::Bool, debuginfo::Ptr{UInt8})::Ref{String}
    return str
end

"""
    code_llvm([io=stdout,], f, types; raw=false, dump_module=false, optimize=true, debuginfo=:default)

Prints the LLVM bitcodes generated for running the method matching the given generic
function and type signature to `io`.

If the `optimize` keyword is unset, the code will be shown before LLVM optimizations.
All metadata and dbg.* calls are removed from the printed bitcode. For the full IR, set the `raw` keyword to true.
To dump the entire module that encapsulates the function (with declarations), set the `dump_module` keyword to true.
Keyword argument `debuginfo` may be one of source (default) or none, to specify the verbosity of code comments.
"""
function code_llvm(io::IO, @nospecialize(f), @nospecialize(types=Base.default_tt(f));
                   raw::Bool=false, dump_module::Bool=false, optimize::Bool=true, debuginfo::Symbol=:default,
                   params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
    d = _dump_function(f, types, false, false, raw, dump_module, :intel, optimize, debuginfo, false, params)
    if highlighting[:llvm] && get(io, :color, false)::Bool
        print_llvm(io, d)
    else
        print(io, d)
    end
end
code_llvm(args...; kwargs...) = (@nospecialize; code_llvm(stdout, args...; kwargs...))

"""
    code_native([io=stdout,], f, types; syntax=:intel, debuginfo=:default, binary=false, dump_module=true)

Prints the native assembly instructions generated for running the method matching the given
generic function and type signature to `io`.

* Set assembly syntax by setting `syntax` to `:intel` (default) for intel syntax or `:att` for AT&T syntax.
* Specify verbosity of code comments by setting `debuginfo` to `:source` (default) or `:none`.
* If `binary` is `true`, also print the binary machine code for each instruction precedented by an abbreviated address.
* If `dump_module` is `false`, do not print metadata such as rodata or directives.
* If `raw` is `false`, uninteresting instructions (like the safepoint function prologue) are elided.

See also: [`@code_native`](@ref), [`code_llvm`](@ref), [`code_typed`](@ref) and [`code_lowered`](@ref)
"""
function code_native(io::IO, @nospecialize(f), @nospecialize(types=Base.default_tt(f));
                     dump_module::Bool=true, syntax::Symbol=:intel, raw::Bool=false,
                     debuginfo::Symbol=:default, binary::Bool=false,
                     params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
    d = _dump_function(f, types, true, false, raw, dump_module, syntax, true, debuginfo, binary, params)
    if highlighting[:native] && get(io, :color, false)::Bool
        print_native(io, d)
    else
        print(io, d)
    end
end
code_native(args...; kwargs...) = (@nospecialize; code_native(stdout, args...; kwargs...))

## colorized IR and assembly printing

const num_regex = r"^(?:\$?-?\d+|0x[0-9A-Fa-f]+|-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)$"

function print_llvm(io::IO, code::String)
    buf = IOBuffer(code)
    for line in eachline(buf)
        m = match(r"^(\s*)((?:[^;]|;\")*)(.*)$", line)
        m === nothing && continue
        indent, tokens, comment = m.captures
        print(io, indent)
        print_llvm_tokens(io, tokens)
        printstyled_ll(io, comment, :comment)
        println(io)
    end
end

const llvm_types =
    r"^(?:void|half|float|double|x86_\w+|ppc_\w+|label|metadata|type|opaque|token|i\d+)$"
const llvm_cond = r"^(?:[ou]?eq|[ou]?ne|[uso][gl][te]|ord|uno)$" # true|false

function print_llvm_tokens(io, tokens)
    m = match(r"^((?:[^\s:]+:)?)(\s*)(.*)", tokens)
    if m !== nothing
        label, spaces, tokens = m.captures
        printstyled_ll(io, label, :label, spaces)
    end
    m = match(r"^(%[^\s=]+)(\s*)=(\s*)(.*)", tokens)
    if m !== nothing
        result, spaces, spaces2, tokens = m.captures
        printstyled_ll(io, result, :variable, spaces)
        printstyled_ll(io, '=', :default, spaces2)
    end
    m = match(r"^([a-z]\w*)(\s*)(.*)", tokens)
    if m !== nothing
        inst, spaces, tokens = m.captures
        iskeyword = occursin(r"^(?:define|declare|type)$", inst) || occursin("=", tokens)
        printstyled_ll(io, inst, iskeyword ? :keyword : :instruction, spaces)
    end

    print_llvm_operands(io, tokens)
end

function print_llvm_operands(io, tokens)
    while !isempty(tokens)
        tokens = print_llvm_operand(io, tokens)
    end
    return tokens
end

function print_llvm_operand(io, tokens)
    islabel = false
    while !isempty(tokens)
        m = match(r"^,(\s*)(.*)", tokens)
        if m !== nothing
            spaces, tokens = m.captures
            printstyled_ll(io, ',', :default, spaces)
            break
        end
        m = match(r"^(\*+|=)(\s*)(.*)", tokens)
        if m !== nothing
            sym, spaces, tokens = m.captures
            printstyled_ll(io, sym, :default, spaces)
            continue
        end
        m = match(r"^(\"[^\"]*\")(\s*)(.*)", tokens)
        if m !== nothing
            str, spaces, tokens = m.captures
            printstyled_ll(io, str, :variable, spaces)
            continue
        end
        m = match(r"^([({\[<])(\s*)(.*)", tokens)
        if m !== nothing
            bracket, spaces, tokens = m.captures
            printstyled_ll(io, bracket, :bracket, spaces)
            tokens = print_llvm_operands(io, tokens) # enter
            continue
        end
        m = match(r"^([)}\]>])(\s*)(.*)", tokens)
        if m !== nothing
            bracket, spaces, tokens = m.captures
            printstyled_ll(io, bracket, :bracket, spaces)
            break # leave
        end

        m = match(r"^([^\s,*=(){}\[\]<>]+)(\s*)(.*)", tokens)
        m === nothing && break
        token, spaces, tokens = m.captures
        if occursin(llvm_types, token)
            printstyled_ll(io, token, :type)
            islabel = token == "label"
        elseif occursin(llvm_cond, token) # condition code is instruction-level
            printstyled_ll(io, token, :instruction)
        elseif occursin(num_regex, token)
            printstyled_ll(io, token, :number)
        elseif occursin(r"^@.+$", token)
            printstyled_ll(io, token, :funcname)
        elseif occursin(r"^%.+$", token)
            islabel |= occursin(r"^%[^\d].*$", token) & occursin(r"^\]", tokens)
            printstyled_ll(io, token, islabel ? :label : :variable)
            islabel = false
        elseif occursin(r"^[a-z]\w+$", token)
            printstyled_ll(io, token, :keyword)
        else
            printstyled_ll(io, token, :default)
        end
        print(io, spaces)
    end
    return tokens
end

function print_native(io::IO, code::String, arch::Symbol=sys_arch_category())
    archv = Val(arch)
    buf = IOBuffer(code)
    for line in eachline(buf)
        m = match(r"^(\s*)((?:[^;#/]|#\S|;\"|/[^/])*)(.*)$", line)
        m === nothing && continue
        indent, tokens, comment = m.captures
        print(io, indent)
        print_native_tokens(io, tokens, archv)
        printstyled_ll(io, comment, :comment)
        println(io)
    end
end

function sys_arch_category()
    if Sys.ARCH === :x86_64 || Sys.ARCH === :i686
        :x86
    elseif Sys.ARCH === :aarch64 || startswith(string(Sys.ARCH), "arm")
        :arm
    else
        :unsupported
    end
end

print_native_tokens(io, line, ::Val) = print(io, line)

const x86_ptr = r"^(?:(?:[xyz]mm|[dq])?word|byte|ptr|offset)$"
const avx512flags = r"^(?:z|r[nduz]-sae|sae|1to1?\d)$"
const arm_cond = r"^(?:eq|ne|cs|ho|cc|lo|mi|pl|vs|vc|hi|ls|[lg][te]|al|nv)$"
const arm_keywords = r"^(?:lsl|lsr|asr|ror|rrx|!|/[zm])$"

function print_native_tokens(io, tokens, arch::Union{Val{:x86}, Val{:arm}})
    x86 = arch isa Val{:x86}
    m = match(r"^((?:[^\s:]+:|\"[^\"]+\":)?)(\s*)(.*)", tokens)
    if m !== nothing
        label, spaces, tokens = m.captures
        printstyled_ll(io, label, :label, spaces)
    end
    haslabel = false
    m = match(r"^([a-z][\w.]*)(\s*)(.*)", tokens)
    if m !== nothing
        instruction, spaces, tokens = m.captures
        printstyled_ll(io, instruction, :instruction, spaces)
        haslabel = occursin(r"^(?:bl?|bl?\.\w{2,5}|[ct]bn?z)?$", instruction)
    end

    isfuncname = false
    while !isempty(tokens)
        m = match(r"^([,:*])(\s*)(.*)", tokens)
        if m !== nothing
            sym, spaces, tokens = m.captures
            printstyled_ll(io, sym, :default, spaces)
            isfuncname = false
            continue
        end
        m = match(r"^([(){}\[\]])(\s*)(.*)", tokens)
        if m !== nothing
            bracket, spaces, tokens = m.captures
            printstyled_ll(io, bracket, :bracket, spaces)
            continue
        end
        m = match(r"^#([0-9a-fx.-]+)(\s*)(.*)", tokens)
        if !x86 && m !== nothing && occursin(num_regex, m.captures[1])
            num, spaces, tokens = m.captures
            printstyled_ll(io, "#" * num, :number, spaces)
            continue
        end

        m = match(r"^([^\s,:*(){}\[\]][^\s,:*/(){}\[\]]*)(\s*)(.*)", tokens)
        m === nothing && break
        token, spaces, tokens = m.captures
        if occursin(num_regex, token)
            printstyled_ll(io, token, :number)
        elseif x86 && occursin(x86_ptr, token) || occursin(avx512flags, token)
            printstyled_ll(io, token, :keyword)
            isfuncname = token == "offset"
        elseif !x86 && (occursin(arm_keywords, token) || occursin(arm_cond, token))
            printstyled_ll(io, token, :keyword)
        elseif occursin(r"^L.+$", token)
            printstyled_ll(io, token, :label)
        elseif occursin(r"^\$.+$", token)
            printstyled_ll(io, token, :funcname)
        elseif occursin(r"^%?(?:[a-z][\w.]+|\"[^\"]+\")$", token)
            islabel = haslabel & !occursin(',', tokens)
            printstyled_ll(io, token, islabel ? :label : isfuncname ? :funcname : :variable)
            isfuncname = false
        else
            printstyled_ll(io, token, :default)
        end
        print(io, spaces)
    end
end

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	# highlighting settings
4	const highlighting = Dict{Symbol, Bool}(
5	:warntype => true,
6	:llvm => true,
7	:native => true,
8	)
9
10	const llstyle = Dict{Symbol, Tuple{Bool, Union{Symbol, Int}}}(
11	:default => (false, :normal), # e.g. comma, equal sign, unknown token
12	:comment => (false, :light_black),
13	:label => (false, :light_red),
14	:instruction => ( true, :light_cyan),
15	:type => (false, :cyan),
16	:number => (false, :yellow),
17	:bracket => (false, :yellow),
18	:variable => (false, :normal), # e.g. variable, register
19	:keyword => (false, :light_magenta),
20	:funcname => (false, :light_yellow),
21	)
22
23	function printstyled_ll(io::IO, x, s::Symbol, trailing_spaces="")	×
24	printstyled(io, x, bold=llstyle[s][1], color=llstyle[s][2])	×
25	print(io, trailing_spaces)	×
26	end
27
28	# displaying type warnings
29
30	function warntype_type_printer(io::IO; @nospecialize(type), used::Bool, show_type::Bool=true, _...)	166✔
31	(show_type && used) \|\| return nothing	116✔
32	str = "::$type"	50✔
33	if !highlighting[:warntype]	50✔
34	print(io, str)	×
35	elseif type isa Union && is_expected_union(type)	50✔
36	Base.emphasize(io, str, Base.warn_color()) # more mild user notification	4✔
37	elseif type isa Type && (!Base.isdispatchelem(type) \|\| type == Core.Box)	90✔
38	Base.emphasize(io, str)	×
39	else
40	Base.printstyled(io, str, color=:cyan) # show the "good" type	46✔
41	end
42	return nothing	50✔
43	end
44
45	# True if one can be pretty certain that the compiler handles this union well,
46	# i.e. must be small with concrete types.
47	function is_expected_union(u::Union)	4✔
48	Base.unionlen(u) < 4 \|\| return false	4✔
49	for x in Base.uniontypes(u)	4✔
50	if !Base.isdispatchelem(x) \|\| x == Core.Box	16✔
51	return false	×
52	end
53	end	12✔
54	return true	4✔
55	end
56
57	"""
58	code_warntype([io::IO], f, types; debuginfo=:default)
59
60	Prints lowered and type-inferred ASTs for the methods matching the given generic function
61	and type signature to `io` which defaults to `stdout`. The ASTs are annotated in such a way
62	as to cause "non-leaf" types which may be problematic for performance to be emphasized
63	(if color is available, displayed in red). This serves as a warning of potential type instability.
64
65	Not all non-leaf types are particularly problematic for performance, and the performance
66	characteristics of a particular type is an implementation detail of the compiler.
67	`code_warntype` will err on the side of coloring types red if they might be a performance
68	concern, so some types may be colored red even if they do not impact performance.
69	Small unions of concrete types are usually not a concern, so these are highlighted in yellow.
70
71	Keyword argument `debuginfo` may be one of `:source` or `:none` (default), to specify the verbosity of code comments.
72
73	See [`@code_warntype`](@ref man-code-warntype) for more information.
74	"""
75	function code_warntype(io::IO, @nospecialize(f), @nospecialize(t=Base.default_tt(f));	4✔
76	debuginfo::Symbol=:default, optimize::Bool=false, kwargs...)
77	debuginfo = Base.IRShow.debuginfo(debuginfo)	2✔
78	lineprinter = Base.IRShow.__debuginfo[debuginfo]	2✔
79	for (src, rettype) in code_typed(f, t; optimize, kwargs...)	2✔
80	if !(src isa Core.CodeInfo)	2✔
81	println(io, src)	×
82	println(io, " failed to infer")	×
83	continue	×
84	end
85	lambda_io::IOContext = io	2✔
86	p = src.parent	2✔
87	nargs::Int = 0	2✔
88	if p isa Core.MethodInstance	2✔
89	println(io, p)	2✔
90	print(io, " from ")	2✔
91	println(io, p.def)	2✔
92	p.def isa Method && (nargs = p.def.nargs)	4✔
93	if !isempty(p.sparam_vals)	2✔
94	println(io, "Static Parameters")	×
95	sig = p.def.sig	×
96	warn_color = Base.warn_color() # more mild user notification	×
97	for i = 1:length(p.sparam_vals)	×
98	sig = sig::UnionAll	×
99	name = sig.var.name	×
100	val = p.sparam_vals[i]	×
101	print_highlighted(io::IO, v::String, color::Symbol) =	×
102	if highlighting[:warntype]
103	Base.printstyled(io, v; color)	×
104	else
105	Base.print(io, v)	×
106	end
107	if val isa TypeVar	×
108	if val.lb === Union{}	×
109	print(io, " ", name, " <: ")	×
110	print_highlighted(io, "$(val.ub)", warn_color)	×
111	elseif val.ub === Any	×
112	print(io, " ", sig.var.name, " >: ")	×
113	print_highlighted(io, "$(val.lb)", warn_color)	×
114	else
115	print(io, " ")	×
116	print_highlighted(io, "$(val.lb)", warn_color)	×
117	print(io, " <: ", sig.var.name, " <: ")	×
118	print_highlighted(io, "$(val.ub)", warn_color)	×
119	end
120	elseif val isa typeof(Vararg)	×
121	print(io, " ", name, "::")	×
122	print_highlighted(io, "Int", warn_color)	×
123	else
124	print(io, " ", sig.var.name, " = ")	×
125	print_highlighted(io, "$(val)", :cyan) # show the "good" type	×
126	end
127	println(io)	×
128	sig = sig.body	×
129	end	×
130	end
131	end
132	if src.slotnames !== nothing	2✔
133	slotnames = Base.sourceinfo_slotnames(src)	2✔
134	lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => slotnames)	2✔
135	slottypes = src.slottypes	2✔
136	nargs > 0 && println(io, "Arguments")	2✔
137	for i = 1:length(slotnames)	4✔
138	if i == nargs + 1	12✔
139	println(io, "Locals")	2✔
140	end
141	print(io, " ", slotnames[i])	12✔
142	if isa(slottypes, Vector{Any})	12✔
143	warntype_type_printer(io; type=slottypes[i], used=true)	12✔
144	end
145	println(io)	12✔
146	end	22✔
147	end
148	print(io, "Body")	2✔
149	warntype_type_printer(io; type=rettype, used=true)	2✔
150	println(io)	2✔
151	irshow_config = Base.IRShow.IRShowConfig(lineprinter(src), warntype_type_printer)	2✔
152	Base.IRShow.show_ir(lambda_io, src, irshow_config)	2✔
153	println(io)	2✔
154	end	4✔
155	nothing	2✔
156	end
157	code_warntype(args...; kwargs...) = (@nospecialize; code_warntype(stdout, args...; kwargs...))	×
158
159	using Base: CodegenParams
160
161	const GENERIC_SIG_WARNING = "; WARNING: This code may not match what actually runs.\n"
162	const OC_MISMATCH_WARNING =
163	"""
164	; WARNING: The pre-inferred opaque closure is not callable with the given arguments
165	; and will error on dispatch with this signature.
166	"""
167
168	# Printing code representations in IR and assembly
169
170	function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrapper::Bool,	71✔
171	raw::Bool, dump_module::Bool, syntax::Symbol,
172	optimize::Bool, debuginfo::Symbol, binary::Bool,
173	params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
174	ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")	71✔
175	if isa(f, Core.Builtin)	66✔
176	throw(ArgumentError("argument is not a generic function"))	×
177	end
178	warning = ""	66✔
179	# get the MethodInstance for the method match
180	if !isa(f, Core.OpaqueClosure)	66✔
181	world = Base.get_world_counter()	64✔
182	match = Base._which(signature_type(f, t); world)	64✔
183	mi = Core.Compiler.specialize_method(match)	64✔
184	# TODO: use jl_is_cacheable_sig instead of isdispatchtuple
185	isdispatchtuple(mi.specTypes) \|\| (warning = GENERIC_SIG_WARNING)	64✔
186	else
187	world = UInt64(f.world)	2✔
188	tt = Base.to_tuple_type(t)	2✔
189	if Core.Compiler.is_source_inferred(f.source.source)	2✔
190	# OC was constructed from inferred source. There's only one
191	# specialization and we can't infer anything more precise either.
192	world = f.source.primary_world	2✔
193	mi = f.source.specializations::Core.MethodInstance	2✔
194	Core.Compiler.hasintersect(typeof(f).parameters[1], tt) \|\| (warning = OC_MISMATCH_WARNING)	2✔
195	else
196	mi = Core.Compiler.specialize_method(f.source, Tuple{typeof(f.captures), tt.parameters...}, Core.svec())	×
197	actual = isdispatchtuple(mi.specTypes)	×
198	isdispatchtuple(mi.specTypes) \|\| (warning = GENERIC_SIG_WARNING)	×
199	end
200	end
201	# get the code for it
202	if debuginfo === :default	66✔
203	debuginfo = :source	27✔
204	elseif debuginfo !== :source && debuginfo !== :none	39✔
205	throw(ArgumentError("'debuginfo' must be either :source or :none"))	×
206	end
207	if native	66✔
208	if syntax !== :att && syntax !== :intel	×
209	throw(ArgumentError("'syntax' must be either :intel or :att"))	×
210	end
211	if dump_module	×
212	# we want module metadata, so use LLVM to generate assembly output
213	str = _dump_function_native_assembly(mi, world, wrapper, syntax, debuginfo, binary, raw, params)	×
214	else
215	# if we don't want the module metadata, just disassemble what our JIT has
216	str = _dump_function_native_disassembly(mi, world, wrapper, syntax, debuginfo, binary)	×
217	end
218	else
219	str = _dump_function_llvm(mi, world, wrapper, !raw, dump_module, optimize, debuginfo, params)	66✔
220	end
221	str = warning * str	66✔
222	return str	66✔
223	end
224
225	function _dump_function_native_disassembly(mi::Core.MethodInstance, world::UInt,	×
226	wrapper::Bool, syntax::Symbol,
227	debuginfo::Symbol, binary::Bool)
228	str = @ccall jl_dump_method_asm(mi::Any, world::UInt, false::Bool, wrapper::Bool,	×
229	syntax::Ptr{UInt8}, debuginfo::Ptr{UInt8},
230	binary::Bool)::Ref{String}
231	return str	×
232	end
233
234	struct LLVMFDump
235	tsm::Ptr{Cvoid} # opaque
236	f::Ptr{Cvoid} # opaque
237	end
238
239	function _dump_function_native_assembly(mi::Core.MethodInstance, world::UInt,	×
240	wrapper::Bool, syntax::Symbol, debuginfo::Symbol,
241	binary::Bool, raw::Bool, params::CodegenParams)
242	llvmf_dump = Ref{LLVMFDump}()	×
243	@ccall jl_get_llvmf_defn(llvmf_dump::Ptr{LLVMFDump},mi::Any, world::UInt, wrapper::Bool,	×
244	true::Bool, params::CodegenParams)::Cvoid
245	llvmf_dump[].f == C_NULL && error("could not compile the specified method")	×
246	str = @ccall jl_dump_function_asm(llvmf_dump::Ptr{LLVMFDump}, false::Bool,	×
247	syntax::Ptr{UInt8}, debuginfo::Ptr{UInt8},
248	binary::Bool, raw::Bool)::Ref{String}
249	return str	×
250	end
251
252	function _dump_function_llvm(	66✔
253	mi::Core.MethodInstance, world::UInt, wrapper::Bool,
254	strip_ir_metadata::Bool, dump_module::Bool,
255	optimize::Bool, debuginfo::Symbol,
256	params::CodegenParams)
257	llvmf_dump = Ref{LLVMFDump}()	66✔
258	@ccall jl_get_llvmf_defn(llvmf_dump::Ptr{LLVMFDump}, mi::Any, world::UInt,	66✔
259	wrapper::Bool, optimize::Bool, params::CodegenParams)::Cvoid
260	llvmf_dump[].f == C_NULL && error("could not compile the specified method")	66✔
261	str = @ccall jl_dump_function_ir(llvmf_dump::Ptr{LLVMFDump}, strip_ir_metadata::Bool,	66✔
262	dump_module::Bool, debuginfo::Ptr{UInt8})::Ref{String}
263	return str	66✔
264	end
265
266	"""
267	code_llvm([io=stdout,], f, types; raw=false, dump_module=false, optimize=true, debuginfo=:default)
268
269	Prints the LLVM bitcodes generated for running the method matching the given generic
270	function and type signature to `io`.
271
272	If the `optimize` keyword is unset, the code will be shown before LLVM optimizations.
273	All metadata and dbg.* calls are removed from the printed bitcode. For the full IR, set the `raw` keyword to true.
274	To dump the entire module that encapsulates the function (with declarations), set the `dump_module` keyword to true.
275	Keyword argument `debuginfo` may be one of source (default) or none, to specify the verbosity of code comments.
276	"""
277	function code_llvm(io::IO, @nospecialize(f), @nospecialize(types=Base.default_tt(f));	60✔
278	raw::Bool=false, dump_module::Bool=false, optimize::Bool=true, debuginfo::Symbol=:default,
279	params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
280	d = _dump_function(f, types, false, false, raw, dump_module, :intel, optimize, debuginfo, false, params)	30✔
281	if highlighting[:llvm] && get(io, :color, false)::Bool	28✔
282	print_llvm(io, d)	×
283	else
284	print(io, d)	28✔
285	end
286	end
287	code_llvm(args...; kwargs...) = (@nospecialize; code_llvm(stdout, args...; kwargs...))	6✔
288
289	"""
290	code_native([io=stdout,], f, types; syntax=:intel, debuginfo=:default, binary=false, dump_module=true)
291
292	Prints the native assembly instructions generated for running the method matching the given
293	generic function and type signature to `io`.
294
295	* Set assembly syntax by setting `syntax` to `:intel` (default) for intel syntax or `:att` for AT&T syntax.
296	* Specify verbosity of code comments by setting `debuginfo` to `:source` (default) or `:none`.
297	* If `binary` is `true`, also print the binary machine code for each instruction precedented by an abbreviated address.
298	* If `dump_module` is `false`, do not print metadata such as rodata or directives.
299	* If `raw` is `false`, uninteresting instructions (like the safepoint function prologue) are elided.
300
301	See also: [`@code_native`](@ref), [`code_llvm`](@ref), [`code_typed`](@ref) and [`code_lowered`](@ref)
302	"""
303	function code_native(io::IO, @nospecialize(f), @nospecialize(types=Base.default_tt(f));	4✔
304	dump_module::Bool=true, syntax::Symbol=:intel, raw::Bool=false,
305	debuginfo::Symbol=:default, binary::Bool=false,
306	params::CodegenParams=CodegenParams(debug_info_kind=Cint(0), safepoint_on_entry=raw, gcstack_arg=raw))
307	d = _dump_function(f, types, true, false, raw, dump_module, syntax, true, debuginfo, binary, params)	2✔
308	if highlighting[:native] && get(io, :color, false)::Bool	×
309	print_native(io, d)	×
310	else
311	print(io, d)	×
312	end
313	end
314	code_native(args...; kwargs...) = (@nospecialize; code_native(stdout, args...; kwargs...))	4✔
315
316	## colorized IR and assembly printing
317
318	const num_regex = r"^(?:\$?-?\d+\|0x[0-9A-Fa-f]+\|-?(?:\d+\.?\d*\|\.\d+)(?:[eE][+-]?\d+)?)$"
319
320	function print_llvm(io::IO, code::String)	×
321	buf = IOBuffer(code)	×
322	for line in eachline(buf)	×
323	m = match(r"^(\s)((?:[^;]\|;\"))(.*)$", line)	×
324	m === nothing && continue	×
325	indent, tokens, comment = m.captures	×
326	print(io, indent)	×
327	print_llvm_tokens(io, tokens)	×
328	printstyled_ll(io, comment, :comment)	×
329	println(io)	×
330	end	×
331	end
332
333	const llvm_types =
334	r"^(?:void\|half\|float\|double\|x86_\w+\|ppc_\w+\|label\|metadata\|type\|opaque\|token\|i\d+)$"
335	const llvm_cond = r"^(?:[ou]?eq\|[ou]?ne\|[uso][gl][te]\|ord\|uno)$" # true\|false
336
337	function print_llvm_tokens(io, tokens)	×
338	m = match(r"^((?:[^\s:]+:)?)(\s)(.)", tokens)	×
339	if m !== nothing	×
340	label, spaces, tokens = m.captures	×
341	printstyled_ll(io, label, :label, spaces)	×
342	end
343	m = match(r"^(%[^\s=]+)(\s)=(\s)(.*)", tokens)	×
344	if m !== nothing	×
345	result, spaces, spaces2, tokens = m.captures	×
346	printstyled_ll(io, result, :variable, spaces)	×
347	printstyled_ll(io, '=', :default, spaces2)	×
348	end
349	m = match(r"^([a-z]\w)(\s)(.*)", tokens)	×
350	if m !== nothing	×
351	inst, spaces, tokens = m.captures	×
352	iskeyword = occursin(r"^(?:define\|declare\|type)$", inst) \|\| occursin("=", tokens)	×
353	printstyled_ll(io, inst, iskeyword ? :keyword : :instruction, spaces)	×
354	end
355
356	print_llvm_operands(io, tokens)	×
357	end
358
359	function print_llvm_operands(io, tokens)	×
360	while !isempty(tokens)	×
361	tokens = print_llvm_operand(io, tokens)	×
362	end	×
363	return tokens	×
364	end
365
366	function print_llvm_operand(io, tokens)	×
367	islabel = false	×
368	while !isempty(tokens)	×
369	m = match(r"^,(\s)(.)", tokens)	×
370	if m !== nothing	×
371	spaces, tokens = m.captures	×
372	printstyled_ll(io, ',', :default, spaces)	×
373	break	×
374	end
375	m = match(r"^(\+\|=)(\s)(.*)", tokens)	×
376	if m !== nothing	×
377	sym, spaces, tokens = m.captures	×
378	printstyled_ll(io, sym, :default, spaces)	×
379	continue	×
380	end
381	m = match(r"^(\"[^\"]\")(\s)(.*)", tokens)	×
382	if m !== nothing	×
383	str, spaces, tokens = m.captures	×
384	printstyled_ll(io, str, :variable, spaces)	×
385	continue	×
386	end
387	m = match(r"^([({\[<])(\s)(.)", tokens)	×
388	if m !== nothing	×
389	bracket, spaces, tokens = m.captures	×
390	printstyled_ll(io, bracket, :bracket, spaces)	×
391	tokens = print_llvm_operands(io, tokens) # enter	×
392	continue	×
393	end
394	m = match(r"^([)}\]>])(\s)(.)", tokens)	×
395	if m !== nothing	×
396	bracket, spaces, tokens = m.captures	×
397	printstyled_ll(io, bracket, :bracket, spaces)	×
398	break # leave	×
399	end
400
401	m = match(r"^([^\s,=(){}\[\]<>]+)(\s)(.*)", tokens)	×
402	m === nothing && break	×
403	token, spaces, tokens = m.captures	×
404	if occursin(llvm_types, token)	×
405	printstyled_ll(io, token, :type)	×
406	islabel = token == "label"	×
407	elseif occursin(llvm_cond, token) # condition code is instruction-level	×
408	printstyled_ll(io, token, :instruction)	×
409	elseif occursin(num_regex, token)	×
410	printstyled_ll(io, token, :number)	×
411	elseif occursin(r"^@.+$", token)	×
412	printstyled_ll(io, token, :funcname)	×
413	elseif occursin(r"^%.+$", token)	×
414	islabel \|= occursin(r"^%[^\d].*$", token) & occursin(r"^\]", tokens)	×
415	printstyled_ll(io, token, islabel ? :label : :variable)	×
416	islabel = false	×
417	elseif occursin(r"^[a-z]\w+$", token)	×
418	printstyled_ll(io, token, :keyword)	×
419	else
420	printstyled_ll(io, token, :default)	×
421	end
422	print(io, spaces)	×
423	end	×
424	return tokens	×
425	end
426
427	function print_native(io::IO, code::String, arch::Symbol=sys_arch_category())	×
428	archv = Val(arch)	×
429	buf = IOBuffer(code)	×
430	for line in eachline(buf)	×
431	m = match(r"^(\s)((?:[^;#/]\|#\S\|;\"\|/[^/]))(.*)$", line)	×
432	m === nothing && continue	×
433	indent, tokens, comment = m.captures	×
434	print(io, indent)	×
435	print_native_tokens(io, tokens, archv)	×
436	printstyled_ll(io, comment, :comment)	×
437	println(io)	×
438	end	×
439	end
440
441	function sys_arch_category()	×
442	if Sys.ARCH === :x86_64 \|\| Sys.ARCH === :i686	×
443	:x86	×
444	elseif Sys.ARCH === :aarch64 \|\| startswith(string(Sys.ARCH), "arm")	×
445	:arm	×
446	else
447	:unsupported	×
448	end
449	end
450
451	print_native_tokens(io, line, ::Val) = print(io, line)	×
452
453	const x86_ptr = r"^(?:(?:[xyz]mm\|[dq])?word\|byte\|ptr\|offset)$"
454	const avx512flags = r"^(?:z\|r[nduz]-sae\|sae\|1to1?\d)$"
455	const arm_cond = r"^(?:eq\|ne\|cs\|ho\|cc\|lo\|mi\|pl\|vs\|vc\|hi\|ls\|[lg][te]\|al\|nv)$"
456	const arm_keywords = r"^(?:lsl\|lsr\|asr\|ror\|rrx\|!\|/[zm])$"
457
458	function print_native_tokens(io, tokens, arch::Union{Val{:x86}, Val{:arm}})	×
459	x86 = arch isa Val{:x86}	×
460	m = match(r"^((?:[^\s:]+:\|\"[^\"]+\":)?)(\s)(.)", tokens)	×
461	if m !== nothing	×
462	label, spaces, tokens = m.captures	×
463	printstyled_ll(io, label, :label, spaces)	×
464	end
465	haslabel = false	×
466	m = match(r"^([a-z][\w.])(\s)(.*)", tokens)	×
467	if m !== nothing	×
468	instruction, spaces, tokens = m.captures	×
469	printstyled_ll(io, instruction, :instruction, spaces)	×
470	haslabel = occursin(r"^(?:bl?\|bl?\.\w{2,5}\|[ct]bn?z)?$", instruction)	×
471	end
472
473	isfuncname = false	×
474	while !isempty(tokens)	×
475	m = match(r"^([,:])(\s)(.*)", tokens)	×
476	if m !== nothing	×
477	sym, spaces, tokens = m.captures	×
478	printstyled_ll(io, sym, :default, spaces)	×
479	isfuncname = false	×
480	continue	×
481	end
482	m = match(r"^([(){}\[\]])(\s)(.)", tokens)	×
483	if m !== nothing	×
484	bracket, spaces, tokens = m.captures	×
485	printstyled_ll(io, bracket, :bracket, spaces)	×
486	continue	×
487	end
488	m = match(r"^#([0-9a-fx.-]+)(\s)(.)", tokens)	×
489	if !x86 && m !== nothing && occursin(num_regex, m.captures[1])	×
490	num, spaces, tokens = m.captures	×
491	printstyled_ll(io, "#" * num, :number, spaces)	×
492	continue	×
493	end
494
495	m = match(r"^([^\s,:(){}\[\]][^\s,:/(){}\[\]])(\s)(.*)", tokens)	×
496	m === nothing && break	×
497	token, spaces, tokens = m.captures	×
498	if occursin(num_regex, token)	×
499	printstyled_ll(io, token, :number)	×
500	elseif x86 && occursin(x86_ptr, token) \|\| occursin(avx512flags, token)	×
501	printstyled_ll(io, token, :keyword)	×
502	isfuncname = token == "offset"	×
503	elseif !x86 && (occursin(arm_keywords, token) \|\| occursin(arm_cond, token))	×
504	printstyled_ll(io, token, :keyword)	×
505	elseif occursin(r"^L.+$", token)	×
506	printstyled_ll(io, token, :label)	×
507	elseif occursin(r"^\$.+$", token)	×
508	printstyled_ll(io, token, :funcname)	×
509	elseif occursin(r"^%?(?:[a-z][\w.]+\|\"[^\"]+\")$", token)	×
510	islabel = haslabel & !occursin(',', tokens)	×
511	printstyled_ll(io, token, islabel ? :label : isfuncname ? :funcname : :variable)	×
512	isfuncname = false	×
513	else
514	printstyled_ll(io, token, :default)	×
515	end
516	print(io, spaces)	×
517	end	×
518	end

JuliaLang / julia / #37623

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous