CompilerPluginTools

JuliaLikeInterpreter <: AbstractInterpreter

Abstract type for julia-like interpreter. The subtype of it usually modifies the native julia interpreter a little bit by overloading certain abstract interpretation interface, but forward most of the interfaces to the native interpreter.

parent(interp::JuliaLikeInterpreter)

Return the native interpreter of Julia.

anymap(f, xs)

Like map, but force to create Vector{Any}.

code_ircode([pass, ]f, types; world=get_world_counter(), interp=NativeInterpreter(world))

Get IRCode by given function f and its argument types types. An option argument pass can be specified as a transform function on IRCode during type inference.

code_ircode_by_mi(f, mi::MethodInstance; world=get_world_counter(), interp=NativeInterpreter(world))

Return the IRCode object along with inferred return type.

Arguments

• f(ir::IRCode, sv::OptimizationState) -> IRCode: optimization passes to run.
• mi::MethodInstance: method instance.

Kwargs

• world::Int: world number, default is calling Core.Compiler.get_world_counter.
• interp::AbstractInterpreter: the interpreter to use for inference.

code_ircode_by_mi(mi::MethodInstance; world=get_world_counter(), interp=NativeInterpreter(world))

The default code_ircode_by_mi that uses the default Julia compiler optimization passes. See also code_ircode_by_mi.

code_ircode_by_signature([pass, ]sig; world=get_world_counter(), interp=NativeInterpreter(world))

Get IRCode by given signature, one can use the first argument to transform the IRCode during interpretation.

const_invoke!(f, ir::IRCode, ref::GlobalRef)

Replace the function invoke Expr(:invoke, _, ref, args...) with f(args...) if its arguments args are all constant.

default_julia_pass(ir::IRCode, sv::OptimizationState)

The default julia optimization pass.

inline_const!(ir::IRCode)

This performs constant propagation on IRCode so after the constant propagation during abstract interpretation, we can force inline constant values in IRCode.

method_instance(f, tt, world=Base.get_world_counter())

Return the MethodInstance, unlike Base.method_instances, tt must be specified type.

no_pass(ir::IRCode, ::OptimizationState)

No pass.

optimize(interp::JuliaLikeInterpreter[, state::OptimizationState], ir::IRCode)

This method is for overloading, it will be executed after running Julia optimizers. If you wish to customize the default Julia optimization passes, consider overloading Core.Compiler.optimize(interp, opt, params, result).

permute_stmts!(ir::IRCode, perm::Vector{Int})

Permute statements according to perm.

typeinf_lock(f)

Type inference lock. This prevents you from recursing into type inference when you don't want. equivalent to the following code, which you may see in Julia compiler implementation.

ccall(:jl_typeinf_begin, Cvoid, ())
ret = f()
ccall(:jl_typeinf_end, Cvoid, ())
return ret

@make_codeinfo begin
    <stmt>::<type>
end

Create a typed CodeInfo object, if field <type> is not specified, it will use Any.

@make_ircode begin
    <stmt>::<type>
end

Create a typed IRCode object, if field <type> is not specified, it will use Any. See also make_codeinfo.