class InsnCompiler

# @param ocb [CodeBlock]

def initialize(cb, ocb, exit_compiler)

@ocb = ocb

@exit_compiler = exit_compiler

# freeze # workaround a binding.irb issue. TODO: resurrect this

end

def compile(jit, ctx, asm, insn)

asm.incr_counter(:mjit_insns_count)

asm.comment("Insn: #{insn.name}")

# Insns

#

def nop(jit, ctx, asm)

# Do nothing

KeepCompiling

end

def getlocal(jit, ctx, asm)

idx = jit.operand(0)

level = jit.operand(1)

jit_getlocal_generic(jit, ctx, asm, idx:, level:)

end

def setlocal(jit, ctx, asm)

idx = jit.operand(0)

level = jit.operand(1)

jit_setlocal_generic(jit, ctx, asm, idx:, level:)

end

def getblockparam(jit, ctx, asm)

# EP level

level = jit.operand(1)

# setblockparam

def getblockparamproxy(jit, ctx, asm)

# To get block_handler

unless jit.at_current_insn?

# getspecial

# setspecial

def getinstancevariable(jit, ctx, asm)

# Specialize on a compile-time receiver, and split a block for chain guards

unless jit.at_current_insn?

jit_getivar(jit, ctx, asm, comptime_obj, id)

end

def setinstancevariable(jit, ctx, asm)

starting_context = ctx.dup # make a copy for use with jit_chain_guard

KeepCompiling

end

def getclassvariable(jit, ctx, asm)

# rb_vm_getclassvariable can raise exceptions.

jit_prepare_routine_call(jit, ctx, asm)

# setclassvariable

def opt_getconstant_path(jit, ctx, asm)

# Cut the block for invalidation

unless jit.at_current_insn?

EndBlock

end

def getconstant(jit, ctx, asm)

id = jit.operand(0)

# getglobal

# setglobal

def putnil(jit, ctx, asm)

putobject(jit, ctx, asm, val: Qnil)

end

def putself(jit, ctx, asm)

stack_top = ctx.stack_push

asm.mov(:rax, [CFP, C.rb_control_frame_t.offsetof(:self)])

KeepCompiling

end

def putobject(jit, ctx, asm, val: jit.operand(0))

# Push it to the stack

stack_top = ctx.stack_push

# putspecialobject

def putstring(jit, ctx, asm)

put_val = jit.operand(0, ruby: true)

KeepCompiling

end

def concatstrings(jit, ctx, asm)

n = jit.operand(0)

KeepCompiling

end

def anytostring(jit, ctx, asm)

# Save the PC and SP since we might call #to_s

jit_prepare_routine_call(jit, ctx, asm)

# toregexp

# intern

def newarray(jit, ctx, asm)

n = jit.operand(0)

# newarraykwsplat

def duparray(jit, ctx, asm)

ary = jit.operand(0)

# duphash

def expandarray(jit, ctx, asm)

# Both arguments are rb_num_t which is unsigned

num = jit.operand(0)

KeepCompiling

end

def concatarray(jit, ctx, asm)

# Save the PC and SP because the callee may allocate

# Note that this modifies REG_SP, which is why we do it first

KeepCompiling

end

def splatarray(jit, ctx, asm)

flag = jit.operand(0)

KeepCompiling

end

def newhash(jit, ctx, asm)

num = jit.operand(0)

# newrange

def pop(jit, ctx, asm)

ctx.stack_pop

KeepCompiling

end

def dup(jit, ctx, asm)

val1 = ctx.stack_opnd(0)

val2 = ctx.stack_push

KeepCompiling

end

def dupn(jit, ctx, asm)

n = jit.operand(0)

KeepCompiling

end

def swap(jit, ctx, asm)

stack0_mem = ctx.stack_opnd(0)

stack1_mem = ctx.stack_opnd(1)

# opt_reverse

def topn(jit, ctx, asm)

n = jit.operand(0)

KeepCompiling

end

def setn(jit, ctx, asm)

n = jit.operand(0)

KeepCompiling

end

def adjuststack(jit, ctx, asm)

n = jit.operand(0)

ctx.stack_pop(n)

KeepCompiling

end

def defined(jit, ctx, asm)

op_type = jit.operand(0)

obj = jit.operand(1, ruby: true)

# definemethod

# definesmethod

def send(jit, ctx, asm)

# Specialize on a compile-time receiver, and split a block for chain guards

unless jit.at_current_insn?

jit_call_general(jit, ctx, asm, mid, argc, flags, cme, block_handler, comptime_recv_klass)

end

def opt_send_without_block(jit, ctx, asm, cd: C.rb_call_data.new(jit.operand(0)))

# Specialize on a compile-time receiver, and split a block for chain guards

unless jit.at_current_insn?

jit_call_general(jit, ctx, asm, mid, argc, flags, cme, C.VM_BLOCK_HANDLER_NONE, comptime_recv_klass)

end

def objtostring(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_str_freeze(jit, ctx, asm)

unless Invariants.assume_bop_not_redefined(jit, C.STRING_REDEFINED_OP_FLAG, C.BOP_FREEZE)

return CantCompile;

KeepCompiling

end

def opt_nil_p(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

# opt_str_uminus

# opt_newarray_max

def opt_newarray_min(jit, ctx, asm)

num = jit.operand(0)

KeepCompiling

end

def invokesuper(jit, ctx, asm)

# Specialize on a compile-time receiver, and split a block for chain guards

unless jit.at_current_insn?

# invokeblock

def leave(jit, ctx, asm)

assert_equal(ctx.stack_size, 1)

# throw

def jump(jit, ctx, asm)

# Check for interrupts, but only on backward branches that may create loops

jump_offset = jit.operand(0, signed: true)

EndBlock

end

def branchif(jit, ctx, asm)

# Check for interrupts, but only on backward branches that may create loops

jump_offset = jit.operand(0, signed: true)

EndBlock

end

def branchunless(jit, ctx, asm)

# Check for interrupts, but only on backward branches that may create loops

jump_offset = jit.operand(0, signed: true)

EndBlock

end

def branchnil(jit, ctx, asm)

# Check for interrupts, but only on backward branches that may create loops

jump_offset = jit.operand(0, signed: true)

# once

def opt_case_dispatch(jit, ctx, asm)

# Just go to === branches for now

ctx.stack_pop

KeepCompiling

end

def opt_plus(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_minus(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_mult(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_div(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_mod(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_eq(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_neq(jit, ctx, asm)

# opt_neq is passed two rb_call_data as arguments:

# first for ==, second for !=

opt_send_without_block(jit, ctx, asm, cd: neq_cd)

end

def opt_lt(jit, ctx, asm)

jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovl, bop: C.BOP_LT)

end

def opt_le(jit, ctx, asm)

jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovle, bop: C.BOP_LE)

end

def opt_gt(jit, ctx, asm)

jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovg, bop: C.BOP_GT)

end

def opt_ge(jit, ctx, asm)

jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovge, bop: C.BOP_GE)

end

def opt_ltlt(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_and(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_or(jit, ctx, asm)

unless jit.at_current_insn?

defer_compilation(jit, ctx, asm)

end

end

def opt_aref(jit, ctx, asm)

cd = C.rb_call_data.new(jit.operand(0))

argc = C.vm_ci_argc(cd.ci)

end

end

def opt_aset(jit, ctx, asm)

# Defer compilation so we can specialize on a runtime `self`

unless jit.at_current_insn?

# opt_aset_with

# opt_aref_with

def opt_length(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_size(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_empty_p(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_succ(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_not(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

def opt_regexpmatch2(jit, ctx, asm)

opt_send_without_block(jit, ctx, asm)

end

KeepCompiling

end

def opt_invokebuiltin_delegate_leave(jit, ctx, asm)

opt_invokebuiltin_delegate(jit, ctx, asm)

# opt_invokebuiltin_delegate is always followed by leave insn

end

def getlocal_WC_0(jit, ctx, asm)

# Get operands

idx = jit.operand(0)

KeepCompiling

end

def getlocal_WC_1(jit, ctx, asm)

idx = jit.operand(0)

jit_getlocal_generic(jit, ctx, asm, idx:, level: 1)

end

def setlocal_WC_0(jit, ctx, asm)

slot_idx = jit.operand(0)

KeepCompiling

end

def setlocal_WC_1(jit, ctx, asm)

idx = jit.operand(0)

jit_setlocal_generic(jit, ctx, asm, idx:, level: 1)

end

def putobject_INT2FIX_0_(jit, ctx, asm)

putobject(jit, ctx, asm, val: C.to_value(0))

end

def putobject_INT2FIX_1_(jit, ctx, asm)

putobject(jit, ctx, asm, val: C.to_value(1))

end

# C func

#

def jit_rb_true(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 0

asm.comment('nil? == true');

true

end

def jit_rb_false(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 0

asm.comment('nil? == false');

true

end

def jit_rb_obj_not(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 0

asm.comment('rb_obj_not')

true

end

def jit_rb_obj_equal(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

asm.comment('equal?')

true

end

def jit_rb_obj_not_equal(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

jit_equality_specialized(jit, ctx, asm, false)

end

def jit_rb_mod_eqq(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

return true

end

def jit_rb_int_equal(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

return false unless two_fixnums_on_stack?(jit)

true

end

def jit_rb_int_mul(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

return false unless two_fixnums_on_stack?(jit)

true

end

def jit_rb_int_aref(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

return false unless two_fixnums_on_stack?(jit)

true

end

def jit_rb_str_to_s(jit, ctx, asm, argc, known_recv_class)

return false if argc != 0

if known_recv_class == String

false

end

def jit_rb_str_getbyte(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

asm.comment('rb_str_getbyte')

true

end

def jit_rb_ary_push(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 1

asm.comment('rb_ary_push')

true

end

def jit_thread_s_current(jit, ctx, asm, argc, _known_recv_class)

return false if argc != 0

asm.comment('Thread.current')

local_table_size - op - 1

end

def guard_object_is_heap(asm, object_opnd, side_exit)

asm.comment('guard object is heap')

# Test that the object is not an immediate

asm.je(side_exit)

end

def guard_object_is_array(asm, object_reg, flags_reg, side_exit)

asm.comment('guard object is array')

# Pull out the type mask

asm.jne(side_exit)

end

def jit_chain_guard(opcode, jit, ctx, asm, side_exit, limit: 20)

opcode => :je | :jne | :jnz | :jz

end

end

def jit_guard_known_klass(jit, ctx, asm, known_klass, obj_opnd, comptime_obj, side_exit, limit: 10)

# Only memory operand is supported for now

assert_equal(true, obj_opnd.is_a?(Array))

end

end

def two_fixnums_on_stack?(jit)

comptime_recv = jit.peek_at_stack(1)

comptime_arg = jit.peek_at_stack(0)

return fixnum?(comptime_recv) && fixnum?(comptime_arg)

end

def guard_two_fixnums(jit, ctx, asm, side_exit)

# Get stack operands without popping them

arg1 = ctx.stack_opnd(0)

# TODO: upgrade type, and skip the check when possible

end

def jit_fixnum_cmp(jit, ctx, asm, opcode:, bop:)

opcode => :cmovl | :cmovle | :cmovg | :cmovge

end

end

def jit_equality_specialized(jit, ctx, asm, gen_eq)

# Create a side-exit to fall back to the interpreter

side_exit = side_exit(jit, ctx)

end

# NOTE: This clobbers :rax

def jit_prepare_routine_call(jit, ctx, asm)

jit.record_boundary_patch_point = true

jit_save_pc(jit, asm)

end

# Note: This clobbers :rax

def jit_save_pc(jit, asm, comment: 'save PC to CFP')

next_pc = jit.pc + jit.insn.len * C.VALUE.size # Use the next one for backtrace and side exits

asm.comment(comment)

asm.mov([CFP, C.rb_control_frame_t.offsetof(:pc)], :rax)

end

def jit_save_sp(jit, ctx, asm)

if ctx.sp_offset != 0

asm.comment('save SP to CFP')

end

end

def jump_to_next_insn(jit, ctx, asm)

reset_depth = ctx.dup

reset_depth.chain_depth = 0

end

# rb_vm_check_ints

def jit_check_ints(jit, ctx, asm)

asm.comment('RUBY_VM_CHECK_INTS(ec)')

asm.mov(:eax, [EC, C.rb_execution_context_t.offsetof(:interrupt_flag)])

end

# GET_LEP

def jit_get_lep(jit, asm, reg:)

level = get_lvar_level(jit.iseq)

jit_get_ep(asm, level, reg:)

end

# vm_get_ep

def jit_get_ep(asm, level, reg:)

asm.mov(reg, [CFP, C.rb_control_frame_t.offsetof(:ep)])

level.times do

end

# vm_getivar

def jit_getivar(jit, ctx, asm, comptime_obj, ivar_id, obj_opnd = nil)

side_exit = side_exit(jit, ctx)

starting_ctx = ctx.dup # copy for jit_chain_guard

end

# vm_caller_setup_arg_block

def jit_caller_setup_arg_block(jit, ctx, asm, ci, blockiseq, is_super)

side_exit = side_exit(jit, ctx)

if C.vm_ci_flag(ci) & C.VM_CALL_ARGS_BLOCKARG != 0

end

# vm_search_method

def jit_search_method(jit, ctx, asm, mid, argc, flags, send_shift: 0)

assert_equal(true, jit.at_current_insn?)

end

# vm_call_general

def jit_call_general(jit, ctx, asm, mid, argc, flags, cme, block_handler, known_recv_class)

jit_call_method(jit, ctx, asm, mid, argc, flags, cme, block_handler, known_recv_class)

end

# vm_call_method

# @param send_shift [Integer] The number of shifts needed for VM_CALL_OPT_SEND

def jit_call_method(jit, ctx, asm, mid, argc, flags, cme, block_handler, known_recv_class, send_shift: 0)

# The main check of vm_call_method before vm_call_method_each_type

end

# vm_call_method_each_type

def jit_call_method_each_type(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)

case cme.def.type

when C.VM_METHOD_TYPE_ISEQ

end

# vm_call_iseq_setup

def jit_call_iseq_setup(jit, ctx, asm, cme, flags, argc, iseq, block_handler, send_shift:, frame_type: nil, prev_ep: nil)

opt_pc = jit_callee_setup_arg(jit, ctx, asm, flags, argc, iseq)

if opt_pc == CantCompile

end

# vm_call_iseq_setup_normal (vm_call_iseq_setup_2 -> vm_call_iseq_setup_normal)

def jit_call_iseq_setup_normal(jit, ctx, asm, cme, flags, argc, iseq, block_handler, opt_pc, send_shift:, frame_type:, prev_ep:)

# We will not have side exits from here. Adjust the stack.

if flags & C.VM_CALL_OPT_SEND != 0

end

# vm_call_cfunc

def jit_call_cfunc(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

if jit_caller_setup_arg(jit, ctx, asm, flags) == CantCompile

return CantCompile

end

# jit_call_cfunc_with_frame

def jit_call_cfunc_with_frame(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

cfunc = cme.def.body.cfunc

end

# vm_call_ivar (+ part of vm_call_method_each_type)

def jit_call_ivar(jit, ctx, asm, cme, flags, argc, comptime_recv, recv_opnd, send_shift:)

if flags & C.VM_CALL_ARGS_SPLAT != 0

asm.incr_counter(:send_ivar_splat)

end

# vm_call_bmethod

def jit_call_bmethod(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)

proc_addr = cme.def.body.bmethod.proc

end

# vm_call_alias

def jit_call_alias(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)

cme = C.rb_aliased_callable_method_entry(cme)

jit_call_method_each_type(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)

end

# vm_call_optimized

def jit_call_optimized(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

if flags & C.VM_CALL_ARGS_BLOCKARG != 0

# Not working yet

end

# vm_call_opt_send

def jit_call_opt_send(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

if jit_caller_setup_arg(jit, ctx, asm, flags) == CantCompile

return CantCompile

end

# vm_call_opt_call

def jit_call_opt_call(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

if block_handler != C.VM_BLOCK_HANDLER_NONE

asm.incr_counter(:send_optimized_call_block)

end

# vm_call_opt_struct_aref

def jit_call_opt_struct_aref(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)

if argc != 0

asm.incr_counter(:send_optimized_struct_aref_error)

EndBlock

end

def jit_call_opt_send_shift_stack(ctx, asm, argc, send_shift:)

# We don't support `send(:send, ...)` for now.

assert_equal(1, send_shift)

end

# vm_call_symbol

def jit_call_symbol(jit, ctx, asm, cme, flags, argc, kw_splat, block_handler, known_recv_class, send_shift:)

flags |= C.VM_CALL_OPT_SEND | (kw_splat ? C.VM_CALL_KW_SPLAT : 0)

# Frame structure:

# | args | locals | cme/cref | block_handler/prev EP | frame type (EP here) | stack bottom (SP here)

#

def jit_push_frame(jit, ctx, asm, cme, flags, argc, frame_type, block_handler, iseq: nil, local_size: 0, stack_max: 0, prev_ep: nil)

# CHECK_VM_STACK_OVERFLOW0: next_cfp <= sp + (local_size + stack_max)

asm.comment('stack overflow check')

end

# vm_callee_setup_arg: Set up args and return opt_pc (or CantCompile)

def jit_callee_setup_arg(jit, ctx, asm, flags, argc, iseq)

if flags & C.VM_CALL_KW_SPLAT == 0

if C.rb_simple_iseq_p(iseq)

end

# CALLER_SETUP_ARG: Return CantCompile if not supported

def jit_caller_setup_arg(jit, ctx, asm, flags)

if flags & C.VM_CALL_ARGS_SPLAT != 0

# We don't support vm_caller_setup_arg_splat

end

# CALLER_REMOVE_EMPTY_KW_SPLAT: Return CantCompile if not supported

def jit_caller_remove_empty_kw_splat(jit, ctx, asm, flags)

if (flags & C.VM_CALL_KW_SPLAT) > 0

# We don't support removing the last Hash argument

C.rb_shape_get_shape_id(obj) == C.OBJ_TOO_COMPLEX_SHAPE_ID

end

def defer_compilation(jit, ctx, asm)

# Make a stub to compile the current insn

stub_next_block(jit.iseq, jit.pc, ctx, asm, comment: 'defer_compilation')

branch_stub.compile.call(asm)

end

def side_exit(jit, ctx)

if side_exit = jit.side_exits[jit.pc]

return side_exit