зеркало из https://github.com/github/ruby.git
RJIT: Migrate SIZET values to RJIT::C constants
This commit is contained in:
Takashi Kokubun
Родитель
50c5f94ed7
Коммит
fe34db5a1b
|
|
@ -179,7 +179,7 @@ module RubyVM::RJIT
|
|||
# Bail when VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) is non zero
|
||||
# FIXME: This is testing bits in the same place that the WB check is testing.
|
||||
# We should combine these at some point
|
||||
asm.test([ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS], C.VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)
|
||||
asm.test([ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS], C::VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)
|
||||
|
||||
# If the frame flag has been modified, then the actual proc value is
|
||||
# already in the EP and we should just use the value.
|
||||
|
|
@ -190,7 +190,7 @@ module RubyVM::RJIT
|
|||
# fire a write barrier for the write, then exit (we'll let the
|
||||
# interpreter handle it so it can fire the write barrier).
|
||||
# flags & VM_ENV_FLAG_WB_REQUIRED
|
||||
asm.test([ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS], C.VM_ENV_FLAG_WB_REQUIRED)
|
||||
asm.test([ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS], C::VM_ENV_FLAG_WB_REQUIRED)
|
||||
|
||||
# if (flags & VM_ENV_FLAG_WB_REQUIRED) != 0
|
||||
asm.jnz(side_exit)
|
||||
|
|
@ -213,9 +213,9 @@ module RubyVM::RJIT
|
|||
asm.mov([ep_reg, offs], C_RET);
|
||||
|
||||
# Set the frame modified flag
|
||||
asm.mov(:rax, [ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS]) # flag_check
|
||||
asm.or(:rax, C.VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) # modified_flag
|
||||
asm.mov([ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS], :rax)
|
||||
asm.mov(:rax, [ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS]) # flag_check
|
||||
asm.or(:rax, C::VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) # modified_flag
|
||||
asm.mov([ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS], :rax)
|
||||
|
||||
asm.write_label(frame_flag_modified)
|
||||
|
||||
|
|
@ -265,7 +265,7 @@ module RubyVM::RJIT
|
|||
jit_get_ep(asm, level, reg: ep_reg)
|
||||
|
||||
# Bail when VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) is non zero
|
||||
asm.test([ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS], C.VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)
|
||||
asm.test([ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS], C::VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)
|
||||
asm.jnz(counted_exit(side_exit, :getblockpp_block_param_modified))
|
||||
|
||||
# Load the block handler for the current frame
|
||||
|
|
@ -343,7 +343,7 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
# Check if the comptime receiver is a T_OBJECT
|
||||
receiver_t_object = C.BUILTIN_TYPE(comptime_receiver) == C.T_OBJECT
|
||||
receiver_t_object = C::BUILTIN_TYPE(comptime_receiver) == C::T_OBJECT
|
||||
|
||||
# If the receiver isn't a T_OBJECT, or uses a custom allocator,
|
||||
# then just write out the IV write as a function call.
|
||||
|
|
@ -418,7 +418,7 @@ module RubyVM::RJIT
|
|||
end
|
||||
new_shape_id = C.rb_shape_id(dest_shape)
|
||||
|
||||
if new_shape_id == C.OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
if new_shape_id == C::OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
asm.incr_counter(:setivar_too_complex)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -454,7 +454,7 @@ module RubyVM::RJIT
|
|||
|
||||
skip_wb = asm.new_label('skip_wb')
|
||||
# If the value we're writing is an immediate, we don't need to WB
|
||||
asm.test(write_val, C.RUBY_IMMEDIATE_MASK)
|
||||
asm.test(write_val, C::RUBY_IMMEDIATE_MASK)
|
||||
asm.jnz(skip_wb)
|
||||
|
||||
# If the value we're writing is nil or false, we don't need to WB
|
||||
|
|
@ -795,7 +795,7 @@ module RubyVM::RJIT
|
|||
# (struct RArray *)(obj)->as.heap.ptr
|
||||
#asm.mov(:rax, array_opnd)
|
||||
asm.mov(:rcx, [:rax, C.RBasic.offsetof(:flags)])
|
||||
asm.test(:rcx, C.RARRAY_EMBED_FLAG);
|
||||
asm.test(:rcx, C::RARRAY_EMBED_FLAG);
|
||||
asm.mov(:rcx, [:rax, C.RArray.offsetof(:as, :heap, :ptr)])
|
||||
|
||||
# Load the address of the embedded array into REG1.
|
||||
|
|
@ -1097,7 +1097,7 @@ module RubyVM::RJIT
|
|||
if cme == CantCompile
|
||||
return CantCompile
|
||||
end
|
||||
jit_call_general(jit, ctx, asm, mid, argc, flags, cme, C.VM_BLOCK_HANDLER_NONE, comptime_recv_klass)
|
||||
jit_call_general(jit, ctx, asm, mid, argc, flags, cme, C::VM_BLOCK_HANDLER_NONE, comptime_recv_klass)
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
|
|
@ -1112,7 +1112,7 @@ module RubyVM::RJIT
|
|||
recv = ctx.stack_opnd(0)
|
||||
comptime_recv = jit.peek_at_stack(0)
|
||||
|
||||
if C.RB_TYPE_P(comptime_recv, C.RUBY_T_STRING)
|
||||
if C::RB_TYPE_P(comptime_recv, C::RUBY_T_STRING)
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
jit_guard_known_klass(jit, ctx, asm, C.rb_class_of(comptime_recv), recv, comptime_recv, side_exit)
|
||||
|
|
@ -1128,7 +1128,7 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def opt_str_freeze(jit, ctx, asm)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.STRING_REDEFINED_OP_FLAG, C.BOP_FREEZE)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::STRING_REDEFINED_OP_FLAG, C::BOP_FREEZE)
|
||||
return CantCompile;
|
||||
end
|
||||
|
||||
|
|
@ -1436,7 +1436,7 @@ module RubyVM::RJIT
|
|||
# Generate a side exit before popping operands
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_PLUS)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_PLUS)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1444,11 +1444,11 @@ module RubyVM::RJIT
|
|||
recv_opnd = ctx.stack_pop
|
||||
|
||||
asm.comment('guard recv is fixnum') # TODO: skip this with type information
|
||||
asm.test(recv_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(recv_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.comment('guard obj is fixnum') # TODO: skip this with type information
|
||||
asm.test(obj_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(obj_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.mov(:rax, recv_opnd)
|
||||
|
|
@ -1482,7 +1482,7 @@ module RubyVM::RJIT
|
|||
# Generate a side exit before popping operands
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_MINUS)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_MINUS)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1490,11 +1490,11 @@ module RubyVM::RJIT
|
|||
recv_opnd = ctx.stack_pop
|
||||
|
||||
asm.comment('guard recv is fixnum') # TODO: skip this with type information
|
||||
asm.test(recv_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(recv_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.comment('guard obj is fixnum') # TODO: skip this with type information
|
||||
asm.test(obj_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(obj_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.mov(:rax, recv_opnd)
|
||||
|
|
@ -1540,7 +1540,7 @@ module RubyVM::RJIT
|
|||
# Note: we generate the side-exit before popping operands from the stack
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_MOD)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_MOD)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1601,28 +1601,28 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def opt_lt(jit, ctx, asm)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovl, bop: C.BOP_LT)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovl, bop: C::BOP_LT)
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def opt_le(jit, ctx, asm)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovle, bop: C.BOP_LE)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovle, bop: C::BOP_LE)
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def opt_gt(jit, ctx, asm)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovg, bop: C.BOP_GT)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovg, bop: C::BOP_GT)
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def opt_ge(jit, ctx, asm)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovge, bop: C.BOP_GE)
|
||||
jit_fixnum_cmp(jit, ctx, asm, opcode: :cmovge, bop: C::BOP_GE)
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
|
|
@ -1646,7 +1646,7 @@ module RubyVM::RJIT
|
|||
# Note: we generate the side-exit before popping operands from the stack
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_AND)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_AND)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1685,7 +1685,7 @@ module RubyVM::RJIT
|
|||
# Note: we generate the side-exit before popping operands from the stack
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_OR)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_OR)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1734,7 +1734,7 @@ module RubyVM::RJIT
|
|||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
if C.rb_class_of(comptime_recv) == Array && fixnum?(comptime_obj)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.ARRAY_REDEFINED_OP_FLAG, C.BOP_AREF)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::ARRAY_REDEFINED_OP_FLAG, C::BOP_AREF)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1746,7 +1746,7 @@ module RubyVM::RJIT
|
|||
|
||||
# Bail if idx is not a FIXNUM
|
||||
asm.mov(:rax, idx_opnd)
|
||||
asm.test(:rax, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(:rax, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(counted_exit(side_exit, :optaref_arg_not_fixnum))
|
||||
|
||||
# Call VALUE rb_ary_entry_internal(VALUE ary, long offset).
|
||||
|
|
@ -1767,7 +1767,7 @@ module RubyVM::RJIT
|
|||
jump_to_next_insn(jit, ctx, asm)
|
||||
EndBlock
|
||||
elsif C.rb_class_of(comptime_recv) == Hash
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.HASH_REDEFINED_OP_FLAG, C.BOP_AREF)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::HASH_REDEFINED_OP_FLAG, C::BOP_AREF)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -1956,7 +1956,7 @@ module RubyVM::RJIT
|
|||
|
||||
bf_argc.times do |i|
|
||||
table_size = jit.iseq.body.local_table_size
|
||||
offs = -table_size - C.VM_ENV_DATA_SIZE + 1 + start_index + i
|
||||
offs = -table_size - C::VM_ENV_DATA_SIZE + 1 + start_index + i
|
||||
asm.mov(C_ARGS[2 + i], [:rax, offs * C.VALUE.size])
|
||||
end
|
||||
end
|
||||
|
|
@ -2019,8 +2019,8 @@ module RubyVM::RJIT
|
|||
# can skip this check.
|
||||
|
||||
# flags & VM_ENV_FLAG_WB_REQUIRED
|
||||
flags_opnd = [ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS]
|
||||
asm.test(flags_opnd, C.VM_ENV_FLAG_WB_REQUIRED)
|
||||
flags_opnd = [ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS]
|
||||
asm.test(flags_opnd, C::VM_ENV_FLAG_WB_REQUIRED)
|
||||
|
||||
# Create a side-exit to fall back to the interpreter
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
|
@ -2417,8 +2417,8 @@ module RubyVM::RJIT
|
|||
# can skip this check.
|
||||
|
||||
# flags & VM_ENV_FLAG_WB_REQUIRED
|
||||
flags_opnd = [ep_reg, C.VALUE.size * C.VM_ENV_DATA_INDEX_FLAGS]
|
||||
asm.test(flags_opnd, C.VM_ENV_FLAG_WB_REQUIRED)
|
||||
flags_opnd = [ep_reg, C.VALUE.size * C::VM_ENV_DATA_INDEX_FLAGS]
|
||||
asm.test(flags_opnd, C::VM_ENV_FLAG_WB_REQUIRED)
|
||||
|
||||
# Create a side-exit to fall back to the interpreter
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
|
@ -2453,7 +2453,7 @@ module RubyVM::RJIT
|
|||
# See usages of local_var_name() from iseq.c for similar calculation.
|
||||
|
||||
local_table_size = iseq.body.local_table_size
|
||||
op = slot_idx - C.VM_ENV_DATA_SIZE
|
||||
op = slot_idx - C::VM_ENV_DATA_SIZE
|
||||
local_table_size - op - 1
|
||||
end
|
||||
|
||||
|
|
@ -2461,7 +2461,7 @@ module RubyVM::RJIT
|
|||
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.test(object_opnd, C.RUBY_IMMEDIATE_MASK)
|
||||
asm.test(object_opnd, C::RUBY_IMMEDIATE_MASK)
|
||||
asm.jnz(side_exit)
|
||||
|
||||
# Test that the object is not false
|
||||
|
|
@ -2474,10 +2474,10 @@ module RubyVM::RJIT
|
|||
asm.comment('guard object is array')
|
||||
# Pull out the type mask
|
||||
asm.mov(flags_reg, [object_reg, C.RBasic.offsetof(:flags)])
|
||||
asm.and(flags_reg, C.RUBY_T_MASK)
|
||||
asm.and(flags_reg, C::RUBY_T_MASK)
|
||||
|
||||
# Compare the result with T_ARRAY
|
||||
asm.cmp(flags_reg, C.RUBY_T_ARRAY)
|
||||
asm.cmp(flags_reg, C::RUBY_T_ARRAY)
|
||||
asm.jne(side_exit)
|
||||
end
|
||||
|
||||
|
|
@ -2536,23 +2536,23 @@ module RubyVM::RJIT
|
|||
jit_chain_guard(:jne, jit, ctx, asm, side_exit, limit:)
|
||||
elsif known_klass == Integer && fixnum?(comptime_obj)
|
||||
asm.comment('guard object is fixnum')
|
||||
asm.test(obj_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(obj_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
jit_chain_guard(:jz, jit, ctx, asm, side_exit, limit:)
|
||||
elsif known_klass == Symbol && static_symbol?(comptime_obj)
|
||||
# We will guard STATIC vs DYNAMIC as though they were separate classes
|
||||
# DYNAMIC symbols can be handled by the general else case below
|
||||
asm.comment('guard object is static symbol')
|
||||
assert_equal(8, C.RUBY_SPECIAL_SHIFT)
|
||||
asm.cmp(BytePtr[*obj_opnd], C.RUBY_SYMBOL_FLAG)
|
||||
assert_equal(8, C::RUBY_SPECIAL_SHIFT)
|
||||
asm.cmp(BytePtr[*obj_opnd], C::RUBY_SYMBOL_FLAG)
|
||||
jit_chain_guard(:jne, jit, ctx, asm, side_exit, limit:)
|
||||
elsif known_klass == Float && flonum?(comptime_obj)
|
||||
# We will guard flonum vs heap float as though they were separate classes
|
||||
asm.comment('guard object is flonum')
|
||||
asm.mov(:rax, obj_opnd)
|
||||
asm.and(:rax, C.RUBY_FLONUM_MASK)
|
||||
asm.cmp(:rax, C.RUBY_FLONUM_FLAG)
|
||||
asm.and(:rax, C::RUBY_FLONUM_MASK)
|
||||
asm.cmp(:rax, C::RUBY_FLONUM_FLAG)
|
||||
jit_chain_guard(:jne, jit, ctx, asm, side_exit, limit:)
|
||||
elsif C.FL_TEST(known_klass, C.RUBY_FL_SINGLETON) && comptime_obj == C.rb_class_attached_object(known_klass)
|
||||
elsif C::FL_TEST(known_klass, C::RUBY_FL_SINGLETON) && comptime_obj == C.rb_class_attached_object(known_klass)
|
||||
asm.comment('guard known object with singleton class')
|
||||
asm.mov(:rax, C.to_value(comptime_obj))
|
||||
asm.cmp(obj_opnd, :rax)
|
||||
|
|
@ -2565,7 +2565,7 @@ module RubyVM::RJIT
|
|||
# Check that the receiver is a heap object
|
||||
# Note: if we get here, the class doesn't have immediate instances.
|
||||
asm.comment('guard not immediate')
|
||||
asm.test(obj_opnd, C.RUBY_IMMEDIATE_MASK)
|
||||
asm.test(obj_opnd, C::RUBY_IMMEDIATE_MASK)
|
||||
jit_chain_guard(:jnz, jit, ctx, asm, side_exit, limit:)
|
||||
asm.cmp(obj_opnd, Qfalse)
|
||||
jit_chain_guard(:je, jit, ctx, asm, side_exit, limit:)
|
||||
|
|
@ -2595,12 +2595,12 @@ module RubyVM::RJIT
|
|||
arg0 = ctx.stack_opnd(1)
|
||||
|
||||
asm.comment('guard arg0 fixnum')
|
||||
asm.test(arg0, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(arg0, C::RUBY_FIXNUM_FLAG)
|
||||
jit_chain_guard(:jz, jit, ctx, asm, side_exit)
|
||||
# TODO: upgrade type, and skip the check when possible
|
||||
|
||||
asm.comment('guard arg1 fixnum')
|
||||
asm.test(arg1, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(arg1, C::RUBY_FIXNUM_FLAG)
|
||||
jit_chain_guard(:jz, jit, ctx, asm, side_exit)
|
||||
# TODO: upgrade type, and skip the check when possible
|
||||
end
|
||||
|
|
@ -2623,7 +2623,7 @@ module RubyVM::RJIT
|
|||
# Generate a side exit before popping operands
|
||||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, bop)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, bop)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
|
|
@ -2631,11 +2631,11 @@ module RubyVM::RJIT
|
|||
recv_opnd = ctx.stack_pop
|
||||
|
||||
asm.comment('guard recv is fixnum') # TODO: skip this with type information
|
||||
asm.test(recv_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(recv_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.comment('guard obj is fixnum') # TODO: skip this with type information
|
||||
asm.test(obj_opnd, C.RUBY_FIXNUM_FLAG)
|
||||
asm.test(obj_opnd, C::RUBY_FIXNUM_FLAG)
|
||||
asm.jz(side_exit)
|
||||
|
||||
asm.mov(:rax, obj_opnd)
|
||||
|
|
@ -2667,7 +2667,7 @@ module RubyVM::RJIT
|
|||
comptime_b = jit.peek_at_stack(0)
|
||||
|
||||
if two_fixnums_on_stack?(jit)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.INTEGER_REDEFINED_OP_FLAG, C.BOP_EQ)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::INTEGER_REDEFINED_OP_FLAG, C::BOP_EQ)
|
||||
return false
|
||||
end
|
||||
|
||||
|
|
@ -2688,7 +2688,7 @@ module RubyVM::RJIT
|
|||
|
||||
true
|
||||
elsif C.rb_class_of(comptime_a) == String && C.rb_class_of(comptime_b) == String
|
||||
unless Invariants.assume_bop_not_redefined(jit, C.STRING_REDEFINED_OP_FLAG, C.BOP_EQ)
|
||||
unless Invariants.assume_bop_not_redefined(jit, C::STRING_REDEFINED_OP_FLAG, C::BOP_EQ)
|
||||
# if overridden, emit the generic version
|
||||
return false
|
||||
end
|
||||
|
|
@ -2835,13 +2835,13 @@ module RubyVM::RJIT
|
|||
starting_ctx = ctx.dup # copy for jit_chain_guard
|
||||
|
||||
# Guard not special const
|
||||
if C.SPECIAL_CONST_P(comptime_obj)
|
||||
if C::SPECIAL_CONST_P(comptime_obj)
|
||||
asm.incr_counter(:getivar_special_const)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
case C.BUILTIN_TYPE(comptime_obj)
|
||||
when C.T_OBJECT
|
||||
case C::BUILTIN_TYPE(comptime_obj)
|
||||
when C::T_OBJECT
|
||||
# This is the only supported case for now (ROBJECT_IVPTR)
|
||||
else
|
||||
# General case. Call rb_ivar_get().
|
||||
|
|
@ -2872,7 +2872,7 @@ module RubyVM::RJIT
|
|||
guard_object_is_heap(asm, :rax, counted_exit(side_exit, :getivar_not_heap))
|
||||
|
||||
shape_id = C.rb_shape_get_shape_id(comptime_obj)
|
||||
if shape_id == C.OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
if shape_id == C::OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
asm.incr_counter(:getivar_too_complex)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -2884,7 +2884,7 @@ module RubyVM::RJIT
|
|||
index = C.rb_shape_get_iv_index(shape_id, ivar_id)
|
||||
if index
|
||||
asm.comment('ROBJECT_IVPTR')
|
||||
if C.FL_TEST_RAW(comptime_obj, C.ROBJECT_EMBED)
|
||||
if C::FL_TEST_RAW(comptime_obj, C::ROBJECT_EMBED)
|
||||
# Access embedded array
|
||||
asm.mov(:rax, [:rax, C.RObject.offsetof(:as, :ary) + (index * C.VALUE.size)])
|
||||
else
|
||||
|
|
@ -2911,7 +2911,7 @@ module RubyVM::RJIT
|
|||
|
||||
def jit_write_iv(asm, comptime_receiver, recv_reg, temp_reg, ivar_index, set_value, needs_extension)
|
||||
# Compile time self is embedded and the ivar index lands within the object
|
||||
embed_test_result = C.FL_TEST_RAW(comptime_receiver, C.ROBJECT_EMBED) && !needs_extension
|
||||
embed_test_result = C::FL_TEST_RAW(comptime_receiver, C::ROBJECT_EMBED) && !needs_extension
|
||||
|
||||
if embed_test_result
|
||||
# Find the IV offset
|
||||
|
|
@ -2940,14 +2940,14 @@ module RubyVM::RJIT
|
|||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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
|
||||
if C.vm_ci_flag(ci) & C::VM_CALL_ARGS_BLOCKARG != 0
|
||||
# TODO: Skip cmp + jne using Context?
|
||||
block_code = jit.peek_at_stack(0)
|
||||
block_opnd = ctx.stack_opnd(0) # to be popped after eliminating side exit possibility
|
||||
if block_code.nil?
|
||||
asm.cmp(block_opnd, Qnil)
|
||||
jit_chain_guard(:jne, jit, ctx, asm, counted_exit(side_exit, :send_block_not_nil))
|
||||
return C.VM_BLOCK_HANDLER_NONE
|
||||
return C::VM_BLOCK_HANDLER_NONE
|
||||
elsif C.to_value(block_code) == C.rb_block_param_proxy
|
||||
asm.mov(:rax, C.rb_block_param_proxy)
|
||||
asm.cmp(block_opnd, :rax)
|
||||
|
|
@ -2965,9 +2965,9 @@ module RubyVM::RJIT
|
|||
# Guard no block passed. Only handle that case for now.
|
||||
asm.comment('guard no block given')
|
||||
jit_get_lep(jit, asm, reg: :rax)
|
||||
asm.cmp([:rax, C.VALUE.size * C::VM_ENV_DATA_INDEX_SPECVAL], C.VM_BLOCK_HANDLER_NONE)
|
||||
asm.cmp([:rax, C.VALUE.size * C::VM_ENV_DATA_INDEX_SPECVAL], C::VM_BLOCK_HANDLER_NONE)
|
||||
asm.jne(counted_exit(side_exit, :send_block_handler))
|
||||
return C.VM_BLOCK_HANDLER_NONE
|
||||
return C::VM_BLOCK_HANDLER_NONE
|
||||
else
|
||||
# Not implemented yet. Is this even necessary?
|
||||
asm.incr_counter(:send_block_setup)
|
||||
|
|
@ -2987,15 +2987,15 @@ module RubyVM::RJIT
|
|||
side_exit = side_exit(jit, ctx)
|
||||
|
||||
# kw_splat is not supported yet
|
||||
if flags & C.VM_CALL_KW_SPLAT != 0
|
||||
if flags & C::VM_CALL_KW_SPLAT != 0
|
||||
asm.incr_counter(:send_kw_splat)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
# Get a compile-time receiver and its class
|
||||
recv_idx = argc + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
recv_idx = argc + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
recv_idx += send_shift
|
||||
comptime_recv = jit.peek_at_stack(recv_idx + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # this offset is in ctx but not in SP
|
||||
comptime_recv = jit.peek_at_stack(recv_idx + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # this offset is in ctx but not in SP
|
||||
comptime_recv_klass = C.rb_class_of(comptime_recv)
|
||||
|
||||
# Guard the receiver class (part of vm_search_method_fastpath)
|
||||
|
|
@ -3037,8 +3037,8 @@ module RubyVM::RJIT
|
|||
|
||||
# vm_search_normal_superclass
|
||||
rbasic_klass = C.to_ruby(C.RBasic.new(C.to_value(current_defined_class)).klass)
|
||||
if C.BUILTIN_TYPE(current_defined_class) == C.RUBY_T_ICLASS && C.BUILTIN_TYPE(rbasic_klass) == C.RUBY_T_MODULE && \
|
||||
C.FL_TEST_RAW(rbasic_klass, C.RMODULE_IS_REFINEMENT) != 0
|
||||
if C::BUILTIN_TYPE(current_defined_class) == C::RUBY_T_ICLASS && C::BUILTIN_TYPE(rbasic_klass) == C::RUBY_T_MODULE && \
|
||||
C::FL_TEST_RAW(rbasic_klass, C::RMODULE_IS_REFINEMENT) != 0
|
||||
return CantCompile
|
||||
end
|
||||
comptime_superclass = C.rb_class_get_superclass(current_defined_class)
|
||||
|
|
@ -3046,11 +3046,11 @@ module RubyVM::RJIT
|
|||
# Don't JIT calls that aren't simple
|
||||
# Note, not using VM_CALL_ARGS_SIMPLE because sometimes we pass a block.
|
||||
|
||||
if flags & C.VM_CALL_KWARG != 0
|
||||
if flags & C::VM_CALL_KWARG != 0
|
||||
asm.incr_counter(:send_kwarg)
|
||||
return CantCompile
|
||||
end
|
||||
if flags & C.VM_CALL_KW_SPLAT != 0
|
||||
if flags & C::VM_CALL_KW_SPLAT != 0
|
||||
asm.incr_counter(:send_kw_splat)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3080,7 +3080,7 @@ module RubyVM::RJIT
|
|||
|
||||
# Check that we'll be able to write this method dispatch before generating checks
|
||||
cme_def_type = cme.def.type
|
||||
if cme_def_type != C.VM_METHOD_TYPE_ISEQ && cme_def_type != C.VM_METHOD_TYPE_CFUNC
|
||||
if cme_def_type != C::VM_METHOD_TYPE_ISEQ && cme_def_type != C::VM_METHOD_TYPE_CFUNC
|
||||
# others unimplemented
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3118,18 +3118,18 @@ module RubyVM::RJIT
|
|||
# @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
|
||||
case C.METHOD_ENTRY_VISI(cme)
|
||||
when C.METHOD_VISI_PUBLIC
|
||||
case C::METHOD_ENTRY_VISI(cme)
|
||||
when C::METHOD_VISI_PUBLIC
|
||||
# You can always call public methods
|
||||
when C.METHOD_VISI_PRIVATE
|
||||
when C::METHOD_VISI_PRIVATE
|
||||
# Allow only callsites without a receiver
|
||||
if flags & C.VM_CALL_FCALL == 0
|
||||
if flags & C::VM_CALL_FCALL == 0
|
||||
asm.incr_counter(:send_private)
|
||||
return CantCompile
|
||||
end
|
||||
when C.METHOD_VISI_PROTECTED
|
||||
when C::METHOD_VISI_PROTECTED
|
||||
# If the method call is an FCALL, it is always valid
|
||||
if flags & C.VM_CALL_FCALL == 0
|
||||
if flags & C::VM_CALL_FCALL == 0
|
||||
# otherwise we need an ancestry check to ensure the receiver is valid to be called as protected
|
||||
jit_protected_callee_ancestry_guard(asm, cme, side_exit(jit, ctx))
|
||||
end
|
||||
|
|
@ -3139,9 +3139,9 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
# Get a compile-time receiver
|
||||
recv_idx = argc + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
recv_idx = argc + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
recv_idx += send_shift
|
||||
comptime_recv = jit.peek_at_stack(recv_idx + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # this offset is in ctx but not in SP
|
||||
comptime_recv = jit.peek_at_stack(recv_idx + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # this offset is in ctx but not in SP
|
||||
recv_opnd = ctx.stack_opnd(recv_idx)
|
||||
|
||||
jit_call_method_each_type(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)
|
||||
|
|
@ -3168,35 +3168,35 @@ module RubyVM::RJIT
|
|||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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
|
||||
when C::VM_METHOD_TYPE_ISEQ
|
||||
iseq = def_iseq_ptr(cme.def)
|
||||
jit_call_iseq_setup(jit, ctx, asm, cme, flags, argc, iseq, block_handler, send_shift:)
|
||||
when C.VM_METHOD_TYPE_NOTIMPLEMENTED
|
||||
when C::VM_METHOD_TYPE_NOTIMPLEMENTED
|
||||
asm.incr_counter(:send_notimplemented)
|
||||
return CantCompile
|
||||
when C.VM_METHOD_TYPE_CFUNC
|
||||
when C::VM_METHOD_TYPE_CFUNC
|
||||
jit_call_cfunc(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)
|
||||
when C.VM_METHOD_TYPE_ATTRSET
|
||||
when C::VM_METHOD_TYPE_ATTRSET
|
||||
asm.incr_counter(:send_attrset)
|
||||
return CantCompile
|
||||
when C.VM_METHOD_TYPE_IVAR
|
||||
when C::VM_METHOD_TYPE_IVAR
|
||||
jit_call_ivar(jit, ctx, asm, cme, flags, argc, comptime_recv, recv_opnd, send_shift:)
|
||||
when C.VM_METHOD_TYPE_MISSING
|
||||
when C::VM_METHOD_TYPE_MISSING
|
||||
asm.incr_counter(:send_missing)
|
||||
return CantCompile
|
||||
when C.VM_METHOD_TYPE_BMETHOD
|
||||
when C::VM_METHOD_TYPE_BMETHOD
|
||||
jit_call_bmethod(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)
|
||||
when C.VM_METHOD_TYPE_ALIAS
|
||||
when C::VM_METHOD_TYPE_ALIAS
|
||||
jit_call_alias(jit, ctx, asm, argc, flags, cme, comptime_recv, recv_opnd, block_handler, known_recv_class, send_shift:)
|
||||
when C.VM_METHOD_TYPE_OPTIMIZED
|
||||
when C::VM_METHOD_TYPE_OPTIMIZED
|
||||
jit_call_optimized(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)
|
||||
when C.VM_METHOD_TYPE_UNDEF
|
||||
when C::VM_METHOD_TYPE_UNDEF
|
||||
asm.incr_counter(:send_undef)
|
||||
return CantCompile
|
||||
when C.VM_METHOD_TYPE_ZSUPER
|
||||
when C::VM_METHOD_TYPE_ZSUPER
|
||||
asm.incr_counter(:send_zsuper)
|
||||
return CantCompile
|
||||
when C.VM_METHOD_TYPE_REFINED
|
||||
when C::VM_METHOD_TYPE_REFINED
|
||||
asm.incr_counter(:send_refined)
|
||||
return CantCompile
|
||||
else
|
||||
|
|
@ -3215,7 +3215,7 @@ module RubyVM::RJIT
|
|||
return CantCompile
|
||||
end
|
||||
|
||||
if flags & C.VM_CALL_TAILCALL != 0
|
||||
if flags & C::VM_CALL_TAILCALL != 0
|
||||
# We don't support vm_call_iseq_setup_tailcall
|
||||
asm.incr_counter(:send_tailcall)
|
||||
return CantCompile
|
||||
|
|
@ -3229,19 +3229,19 @@ module RubyVM::RJIT
|
|||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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
|
||||
if flags & C::VM_CALL_OPT_SEND != 0
|
||||
jit_call_opt_send_shift_stack(ctx, asm, argc, send_shift:)
|
||||
end
|
||||
|
||||
# Save caller SP and PC before pushing a callee frame for backtrace and side exits
|
||||
asm.comment('save SP to caller CFP')
|
||||
recv_idx = argc + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
recv_idx = argc + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0) # blockarg is not popped yet
|
||||
# Skip setting this to SP register. This cfp->sp will be copied to SP on leave insn.
|
||||
asm.lea(:rax, ctx.sp_opnd(C.VALUE.size * -(1 + recv_idx))) # Pop receiver and arguments to prepare for side exits
|
||||
asm.mov([CFP, C.rb_control_frame_t.offsetof(:sp)], :rax)
|
||||
jit_save_pc(jit, asm, comment: 'save PC to caller CFP')
|
||||
|
||||
frame_type ||= C.VM_FRAME_MAGIC_METHOD | C.VM_ENV_FLAG_LOCAL
|
||||
frame_type ||= C::VM_FRAME_MAGIC_METHOD | C::VM_ENV_FLAG_LOCAL
|
||||
jit_push_frame(
|
||||
jit, ctx, asm, cme, flags, argc, frame_type, block_handler,
|
||||
iseq: iseq,
|
||||
|
|
@ -3285,13 +3285,13 @@ module RubyVM::RJIT
|
|||
return CantCompile
|
||||
end
|
||||
|
||||
frame_type = C.VM_FRAME_MAGIC_CFUNC | C.VM_FRAME_FLAG_CFRAME | C.VM_ENV_FLAG_LOCAL
|
||||
if flags & C.VM_CALL_KW_SPLAT != 0
|
||||
frame_type |= C.VM_FRAME_FLAG_CFRAME_KW
|
||||
frame_type = C::VM_FRAME_MAGIC_CFUNC | C::VM_FRAME_FLAG_CFRAME | C::VM_ENV_FLAG_LOCAL
|
||||
if flags & C::VM_CALL_KW_SPLAT != 0
|
||||
frame_type |= C::VM_FRAME_FLAG_CFRAME_KW
|
||||
end
|
||||
|
||||
# EXEC_EVENT_HOOK: RUBY_EVENT_C_CALL and RUBY_EVENT_C_RETURN
|
||||
if C.rb_rjit_global_events & (C.RUBY_EVENT_C_CALL | C.RUBY_EVENT_C_RETURN) != 0
|
||||
if C.rb_rjit_global_events & (C::RUBY_EVENT_C_CALL | C::RUBY_EVENT_C_RETURN) != 0
|
||||
asm.incr_counter(:send_c_tracing)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3307,7 +3307,7 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
# Delegate to codegen for C methods if we have it.
|
||||
if flags & C.VM_CALL_KWARG == 0 && flags & C.VM_CALL_OPT_SEND == 0
|
||||
if flags & C::VM_CALL_KWARG == 0 && flags & C::VM_CALL_OPT_SEND == 0
|
||||
known_cfunc_codegen = lookup_cfunc_codegen(cme.def)
|
||||
if known_cfunc_codegen&.call(jit, ctx, asm, argc, known_recv_class)
|
||||
# cfunc codegen generated code. Terminate the block so
|
||||
|
|
@ -3318,7 +3318,7 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
# We will not have side exits from here. Adjust the stack.
|
||||
if flags & C.VM_CALL_OPT_SEND != 0
|
||||
if flags & C::VM_CALL_OPT_SEND != 0
|
||||
jit_call_opt_send_shift_stack(ctx, asm, argc, send_shift:)
|
||||
end
|
||||
|
||||
|
|
@ -3327,7 +3327,7 @@ module RubyVM::RJIT
|
|||
|
||||
# Save caller SP and PC before pushing a callee frame for backtrace and side exits
|
||||
asm.comment('save SP to caller CFP')
|
||||
sp_index = -(1 + argc + (flags & C.VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # Pop receiver and arguments for side exits. blockarg is not popped yet
|
||||
sp_index = -(1 + argc + (flags & C::VM_CALL_ARGS_BLOCKARG != 0 ? 1 : 0)) # Pop receiver and arguments for side exits. blockarg is not popped yet
|
||||
asm.lea(SP, ctx.sp_opnd(C.VALUE.size * sp_index))
|
||||
asm.mov([CFP, C.rb_control_frame_t.offsetof(:sp)], SP)
|
||||
ctx.sp_offset = -sp_index
|
||||
|
|
@ -3372,7 +3372,7 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def jit_call_ivar(jit, ctx, asm, cme, flags, argc, comptime_recv, recv_opnd, send_shift:)
|
||||
if flags & C.VM_CALL_ARGS_SPLAT != 0
|
||||
if flags & C::VM_CALL_ARGS_SPLAT != 0
|
||||
asm.incr_counter(:send_ivar_splat)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3383,7 +3383,7 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
# We don't support jit_call_opt_send_shift_stack for this yet.
|
||||
if flags & C.VM_CALL_OPT_SEND != 0
|
||||
if flags & C::VM_CALL_OPT_SEND != 0
|
||||
asm.incr_counter(:send_ivar_opt_send)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3391,7 +3391,7 @@ module RubyVM::RJIT
|
|||
ivar_id = cme.def.body.attr.id
|
||||
|
||||
# Not handling block_handler
|
||||
if flags & C.VM_CALL_ARGS_BLOCKARG != 0
|
||||
if flags & C::VM_CALL_ARGS_BLOCKARG != 0
|
||||
asm.incr_counter(:send_ivar_blockarg)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3426,12 +3426,12 @@ module RubyVM::RJIT
|
|||
|
||||
# Passing a block to a block needs logic different from passing
|
||||
# a block to a method and sometimes requires allocation. Bail for now.
|
||||
if block_handler != C.VM_BLOCK_HANDLER_NONE
|
||||
if block_handler != C::VM_BLOCK_HANDLER_NONE
|
||||
asm.incr_counter(:send_bmethod_blockarg)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
frame_type = C.VM_FRAME_MAGIC_BLOCK | C.VM_FRAME_FLAG_BMETHOD | C.VM_FRAME_FLAG_LAMBDA
|
||||
frame_type = C::VM_FRAME_MAGIC_BLOCK | C::VM_FRAME_FLAG_BMETHOD | C::VM_FRAME_FLAG_LAMBDA
|
||||
prev_ep = capture.ep
|
||||
jit_call_iseq_setup(jit, ctx, asm, cme, flags, argc, iseq, block_handler, send_shift:, frame_type:, prev_ep:)
|
||||
end
|
||||
|
|
@ -3450,23 +3450,23 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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
|
||||
if flags & C::VM_CALL_ARGS_BLOCKARG != 0
|
||||
# Not working yet
|
||||
asm.incr_counter(:send_optimized_blockarg)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
case cme.def.body.optimized.type
|
||||
when C.OPTIMIZED_METHOD_TYPE_SEND
|
||||
when C::OPTIMIZED_METHOD_TYPE_SEND
|
||||
jit_call_opt_send(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)
|
||||
when C.OPTIMIZED_METHOD_TYPE_CALL
|
||||
when C::OPTIMIZED_METHOD_TYPE_CALL
|
||||
jit_call_opt_call(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)
|
||||
when C.OPTIMIZED_METHOD_TYPE_BLOCK_CALL
|
||||
when C::OPTIMIZED_METHOD_TYPE_BLOCK_CALL
|
||||
asm.incr_counter(:send_optimized_block_call)
|
||||
return CantCompile
|
||||
when C.OPTIMIZED_METHOD_TYPE_STRUCT_AREF
|
||||
when C::OPTIMIZED_METHOD_TYPE_STRUCT_AREF
|
||||
jit_call_opt_struct_aref(jit, ctx, asm, cme, flags, argc, block_handler, known_recv_class, send_shift:)
|
||||
when C.OPTIMIZED_METHOD_TYPE_STRUCT_ASET
|
||||
when C::OPTIMIZED_METHOD_TYPE_STRUCT_ASET
|
||||
asm.incr_counter(:send_optimized_struct_aset)
|
||||
return CantCompile
|
||||
else
|
||||
|
|
@ -3499,8 +3499,8 @@ module RubyVM::RJIT
|
|||
# where you never exit. `send_shift` signals to lazily shift the stack by this amount.
|
||||
send_shift += 1
|
||||
|
||||
kw_splat = flags & C.VM_CALL_KW_SPLAT != 0
|
||||
jit_call_symbol(jit, ctx, asm, cme, C.VM_CALL_FCALL, argc, kw_splat, block_handler, known_recv_class, send_shift:)
|
||||
kw_splat = flags & C::VM_CALL_KW_SPLAT != 0
|
||||
jit_call_symbol(jit, ctx, asm, cme, C::VM_CALL_FCALL, argc, kw_splat, block_handler, known_recv_class, send_shift:)
|
||||
end
|
||||
|
||||
# vm_call_opt_call
|
||||
|
|
@ -3508,17 +3508,17 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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
|
||||
if block_handler != C::VM_BLOCK_HANDLER_NONE
|
||||
asm.incr_counter(:send_optimized_call_block)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
if flags & C.VM_CALL_KWARG != 0
|
||||
if flags & C::VM_CALL_KWARG != 0
|
||||
asm.incr_counter(:send_optimized_call_kwarg)
|
||||
return CantCompile
|
||||
end
|
||||
|
||||
if flags & C.VM_CALL_ARGS_SPLAT != 0
|
||||
if flags & C::VM_CALL_ARGS_SPLAT != 0
|
||||
asm.incr_counter(:send_optimized_call_splat)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3531,7 +3531,7 @@ module RubyVM::RJIT
|
|||
# end
|
||||
|
||||
# If this is a .send call we need to adjust the stack
|
||||
if flags & C.VM_CALL_OPT_SEND != 0
|
||||
if flags & C::VM_CALL_OPT_SEND != 0
|
||||
jit_call_opt_send_shift_stack(ctx, asm, argc, send_shift:)
|
||||
end
|
||||
|
||||
|
|
@ -3544,14 +3544,14 @@ module RubyVM::RJIT
|
|||
|
||||
asm.lea(:rax, ctx.sp_opnd(0)) # sp
|
||||
|
||||
kw_splat = flags & C.VM_CALL_KW_SPLAT
|
||||
kw_splat = flags & C::VM_CALL_KW_SPLAT
|
||||
|
||||
asm.mov(C_ARGS[0], :rcx)
|
||||
asm.mov(C_ARGS[1], EC)
|
||||
asm.mov(C_ARGS[2], argc)
|
||||
asm.lea(C_ARGS[3], [:rax, -argc * C.VALUE.size]) # stack_argument_pointer. NOTE: C_ARGS[3] is rcx
|
||||
asm.mov(C_ARGS[4], kw_splat)
|
||||
asm.mov(C_ARGS[5], C.VM_BLOCK_HANDLER_NONE)
|
||||
asm.mov(C_ARGS[5], C::VM_BLOCK_HANDLER_NONE)
|
||||
asm.call(C.rjit_optimized_call)
|
||||
|
||||
ctx.stack_pop(argc + 1)
|
||||
|
|
@ -3578,7 +3578,7 @@ module RubyVM::RJIT
|
|||
comptime_recv = jit.peek_at_stack(recv_idx)
|
||||
|
||||
# This is a .send call and we need to adjust the stack
|
||||
if flags & C.VM_CALL_OPT_SEND != 0
|
||||
if flags & C::VM_CALL_OPT_SEND != 0
|
||||
jit_call_opt_send_shift_stack(ctx, asm, argc, send_shift:)
|
||||
end
|
||||
|
||||
|
|
@ -3586,7 +3586,7 @@ module RubyVM::RJIT
|
|||
# length. So if our comptime_recv is embedded all runtime
|
||||
# structs of the same class should be as well, and the same is
|
||||
# true of the converse.
|
||||
embedded = C.FL_TEST_RAW(comptime_recv, C.RSTRUCT_EMBED_LEN_MASK)
|
||||
embedded = C::FL_TEST_RAW(comptime_recv, C::RSTRUCT_EMBED_LEN_MASK)
|
||||
|
||||
asm.comment('struct aref')
|
||||
asm.mov(:rax, ctx.stack_pop(1)) # recv
|
||||
|
|
@ -3627,7 +3627,7 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
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)
|
||||
flags |= C::VM_CALL_OPT_SEND | (kw_splat ? C::VM_CALL_KW_SPLAT : 0)
|
||||
|
||||
comptime_symbol = jit.peek_at_stack(argc)
|
||||
if comptime_symbol.class != String && !static_symbol?(comptime_symbol)
|
||||
|
|
@ -3656,7 +3656,7 @@ module RubyVM::RJIT
|
|||
return CantCompile
|
||||
end
|
||||
|
||||
if flags & C.VM_CALL_FCALL != 0
|
||||
if flags & C::VM_CALL_FCALL != 0
|
||||
return jit_call_method(jit, ctx, asm, mid, argc, flags, cme, block_handler, known_recv_class, send_shift:)
|
||||
end
|
||||
|
||||
|
|
@ -3679,7 +3679,7 @@ module RubyVM::RJIT
|
|||
asm.jbe(counted_exit(side_exit(jit, ctx), :send_stackoverflow))
|
||||
|
||||
# Pop blockarg after all side exits
|
||||
if flags & C.VM_CALL_ARGS_BLOCKARG != 0
|
||||
if flags & C::VM_CALL_ARGS_BLOCKARG != 0
|
||||
ctx.stack_pop(1)
|
||||
end
|
||||
|
||||
|
|
@ -3704,8 +3704,8 @@ module RubyVM::RJIT
|
|||
if prev_ep
|
||||
asm.mov(:rax, prev_ep.to_i | 1) # tagged prev ep
|
||||
asm.mov([SP, C.VALUE.size * (ep_offset - 1)], :rax)
|
||||
elsif block_handler == C.VM_BLOCK_HANDLER_NONE
|
||||
asm.mov([SP, C.VALUE.size * (ep_offset - 1)], C.VM_BLOCK_HANDLER_NONE)
|
||||
elsif block_handler == C::VM_BLOCK_HANDLER_NONE
|
||||
asm.mov([SP, C.VALUE.size * (ep_offset - 1)], C::VM_BLOCK_HANDLER_NONE)
|
||||
elsif block_handler == C.rb_block_param_proxy
|
||||
# vm_caller_setup_arg_block:
|
||||
# VALUE handler = VM_CF_BLOCK_HANDLER(reg_cfp);
|
||||
|
|
@ -3787,7 +3787,7 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def jit_callee_setup_arg(jit, ctx, asm, flags, argc, iseq)
|
||||
if flags & C.VM_CALL_KW_SPLAT == 0
|
||||
if flags & C::VM_CALL_KW_SPLAT == 0
|
||||
if C.rb_simple_iseq_p(iseq)
|
||||
if jit_caller_setup_arg(jit, ctx, asm, flags) == CantCompile
|
||||
return CantCompile
|
||||
|
|
@ -3822,7 +3822,7 @@ module RubyVM::RJIT
|
|||
# Qnil push is handled in jit_push_frame
|
||||
|
||||
return iseq.body.param.opt_table[opt]
|
||||
elsif C.rb_iseq_only_kwparam_p(iseq) && (flags & C.VM_CALL_ARGS_SPLAT) == 0
|
||||
elsif C.rb_iseq_only_kwparam_p(iseq) && (flags & C::VM_CALL_ARGS_SPLAT) == 0
|
||||
asm.incr_counter(:send_iseq_kwparam)
|
||||
return CantCompile
|
||||
end
|
||||
|
|
@ -3838,12 +3838,12 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def jit_caller_setup_arg(jit, ctx, asm, flags)
|
||||
if flags & C.VM_CALL_ARGS_SPLAT != 0
|
||||
if flags & C::VM_CALL_ARGS_SPLAT != 0
|
||||
# We don't support vm_caller_setup_arg_splat
|
||||
asm.incr_counter(:send_args_splat)
|
||||
return CantCompile
|
||||
end
|
||||
if flags & (C.VM_CALL_KWARG | C.VM_CALL_KW_SPLAT) != 0
|
||||
if flags & (C::VM_CALL_KWARG | C::VM_CALL_KW_SPLAT) != 0
|
||||
# We don't support keyword args either
|
||||
asm.incr_counter(:send_kwarg)
|
||||
return CantCompile
|
||||
|
|
@ -3855,7 +3855,7 @@ module RubyVM::RJIT
|
|||
# @param ctx [RubyVM::RJIT::Context]
|
||||
# @param asm [RubyVM::RJIT::Assembler]
|
||||
def jit_caller_remove_empty_kw_splat(jit, ctx, asm, flags)
|
||||
if (flags & C.VM_CALL_KW_SPLAT) > 0
|
||||
if (flags & C::VM_CALL_KW_SPLAT) > 0
|
||||
# We don't support removing the last Hash argument
|
||||
asm.incr_counter(:send_kw_splat)
|
||||
return CantCompile
|
||||
|
|
@ -3871,11 +3871,11 @@ module RubyVM::RJIT
|
|||
asm.mov(len_reg, [array_reg, C.RBasic.offsetof(:flags)])
|
||||
|
||||
# Get the length of the array
|
||||
asm.and(len_reg, C.RARRAY_EMBED_LEN_MASK)
|
||||
asm.sar(len_reg, C.RARRAY_EMBED_LEN_SHIFT)
|
||||
asm.and(len_reg, C::RARRAY_EMBED_LEN_MASK)
|
||||
asm.sar(len_reg, C::RARRAY_EMBED_LEN_SHIFT)
|
||||
|
||||
# Conditionally move the length of the heap array
|
||||
asm.test([array_reg, C.RBasic.offsetof(:flags)], C.RARRAY_EMBED_FLAG)
|
||||
asm.test([array_reg, C.RBasic.offsetof(:flags)], C::RARRAY_EMBED_FLAG)
|
||||
|
||||
# Select the array length value
|
||||
asm.cmovz(len_reg, [array_reg, C.RArray.offsetof(:as, :heap, :len)])
|
||||
|
|
@ -3888,19 +3888,19 @@ module RubyVM::RJIT
|
|||
end
|
||||
|
||||
def fixnum?(obj)
|
||||
(C.to_value(obj) & C.RUBY_FIXNUM_FLAG) == C.RUBY_FIXNUM_FLAG
|
||||
(C.to_value(obj) & C::RUBY_FIXNUM_FLAG) == C::RUBY_FIXNUM_FLAG
|
||||
end
|
||||
|
||||
def flonum?(obj)
|
||||
(C.to_value(obj) & C.RUBY_FLONUM_MASK) == C.RUBY_FLONUM_FLAG
|
||||
(C.to_value(obj) & C::RUBY_FLONUM_MASK) == C::RUBY_FLONUM_FLAG
|
||||
end
|
||||
|
||||
def static_symbol?(obj)
|
||||
(C.to_value(obj) & 0xff) == C.RUBY_SYMBOL_FLAG
|
||||
(C.to_value(obj) & 0xff) == C::RUBY_SYMBOL_FLAG
|
||||
end
|
||||
|
||||
def shape_too_complex?(obj)
|
||||
C.rb_shape_get_shape_id(obj) == C.OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
C.rb_shape_get_shape_id(obj) == C::OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
end
|
||||
|
||||
# @param jit [RubyVM::RJIT::JITState]
|
||||
|
|
|
|||
450
rjit_c.rb
450
rjit_c.rb
|
|
@ -314,366 +314,96 @@ module RubyVM::RJIT # :nodoc: all
|
|||
|
||||
C::VM_ENV_DATA_INDEX_ME_CREF = Primitive.cexpr! %q{ LONG2NUM(VM_ENV_DATA_INDEX_ME_CREF) }
|
||||
C::VM_ENV_DATA_INDEX_SPECVAL = Primitive.cexpr! %q{ LONG2NUM(VM_ENV_DATA_INDEX_SPECVAL) }
|
||||
|
||||
def C.ARRAY_REDEFINED_OP_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(ARRAY_REDEFINED_OP_FLAG) }
|
||||
end
|
||||
|
||||
def C.BOP_AND
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_AND) }
|
||||
end
|
||||
|
||||
def C.BOP_AREF
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_AREF) }
|
||||
end
|
||||
|
||||
def C.BOP_EQ
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_EQ) }
|
||||
end
|
||||
|
||||
def C.BOP_FREEZE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_FREEZE) }
|
||||
end
|
||||
|
||||
def C.BOP_GE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_GE) }
|
||||
end
|
||||
|
||||
def C.BOP_GT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_GT) }
|
||||
end
|
||||
|
||||
def C.BOP_LE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_LE) }
|
||||
end
|
||||
|
||||
def C.BOP_LT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_LT) }
|
||||
end
|
||||
|
||||
def C.BOP_MINUS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_MINUS) }
|
||||
end
|
||||
|
||||
def C.BOP_MOD
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_MOD) }
|
||||
end
|
||||
|
||||
def C.BOP_OR
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_OR) }
|
||||
end
|
||||
|
||||
def C.BOP_PLUS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(BOP_PLUS) }
|
||||
end
|
||||
|
||||
def C.HASH_REDEFINED_OP_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(HASH_REDEFINED_OP_FLAG) }
|
||||
end
|
||||
|
||||
def C.INTEGER_REDEFINED_OP_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(INTEGER_REDEFINED_OP_FLAG) }
|
||||
end
|
||||
|
||||
def C.INVALID_SHAPE_ID
|
||||
Primitive.cexpr! %q{ SIZET2NUM(INVALID_SHAPE_ID) }
|
||||
end
|
||||
|
||||
def C.METHOD_VISI_PRIVATE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PRIVATE) }
|
||||
end
|
||||
|
||||
def C.METHOD_VISI_PROTECTED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PROTECTED) }
|
||||
end
|
||||
|
||||
def C.METHOD_VISI_PUBLIC
|
||||
Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PUBLIC) }
|
||||
end
|
||||
|
||||
def C.OBJ_TOO_COMPLEX_SHAPE_ID
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OBJ_TOO_COMPLEX_SHAPE_ID) }
|
||||
end
|
||||
|
||||
def C.OPTIMIZED_METHOD_TYPE_BLOCK_CALL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_BLOCK_CALL) }
|
||||
end
|
||||
|
||||
def C.OPTIMIZED_METHOD_TYPE_CALL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_CALL) }
|
||||
end
|
||||
|
||||
def C.OPTIMIZED_METHOD_TYPE_SEND
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_SEND) }
|
||||
end
|
||||
|
||||
def C.OPTIMIZED_METHOD_TYPE_STRUCT_AREF
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_STRUCT_AREF) }
|
||||
end
|
||||
|
||||
def C.OPTIMIZED_METHOD_TYPE_STRUCT_ASET
|
||||
Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_STRUCT_ASET) }
|
||||
end
|
||||
|
||||
def C.RARRAY_EMBED_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_FLAG) }
|
||||
end
|
||||
|
||||
def C.RARRAY_EMBED_LEN_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_LEN_MASK) }
|
||||
end
|
||||
|
||||
def C.RARRAY_EMBED_LEN_SHIFT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_LEN_SHIFT) }
|
||||
end
|
||||
|
||||
def C.RMODULE_IS_REFINEMENT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RMODULE_IS_REFINEMENT) }
|
||||
end
|
||||
|
||||
def C.ROBJECT_EMBED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(ROBJECT_EMBED) }
|
||||
end
|
||||
|
||||
def C.RSTRUCT_EMBED_LEN_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RSTRUCT_EMBED_LEN_MASK) }
|
||||
end
|
||||
|
||||
def C.RUBY_EVENT_CLASS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_CLASS) }
|
||||
end
|
||||
|
||||
def C.RUBY_EVENT_C_CALL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_C_CALL) }
|
||||
end
|
||||
|
||||
def C.RUBY_EVENT_C_RETURN
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_C_RETURN) }
|
||||
end
|
||||
|
||||
def C.RUBY_FIXNUM_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_FIXNUM_FLAG) }
|
||||
end
|
||||
|
||||
def C.RUBY_FLONUM_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_FLONUM_FLAG) }
|
||||
end
|
||||
|
||||
def C.RUBY_FLONUM_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_FLONUM_MASK) }
|
||||
end
|
||||
|
||||
def C.RUBY_FL_SINGLETON
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_FL_SINGLETON) }
|
||||
end
|
||||
|
||||
def C.RUBY_IMMEDIATE_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_IMMEDIATE_MASK) }
|
||||
end
|
||||
|
||||
def C.RUBY_SPECIAL_SHIFT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_SPECIAL_SHIFT) }
|
||||
end
|
||||
|
||||
def C.RUBY_SYMBOL_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_SYMBOL_FLAG) }
|
||||
end
|
||||
|
||||
def C.RUBY_T_ARRAY
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_ARRAY) }
|
||||
end
|
||||
|
||||
def C.RUBY_T_ICLASS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_ICLASS) }
|
||||
end
|
||||
|
||||
def C.RUBY_T_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_MASK) }
|
||||
end
|
||||
|
||||
def C.RUBY_T_MODULE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_MODULE) }
|
||||
end
|
||||
|
||||
def C.RUBY_T_STRING
|
||||
Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_STRING) }
|
||||
end
|
||||
|
||||
def C.SHAPE_CAPACITY_CHANGE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_CAPACITY_CHANGE) }
|
||||
end
|
||||
|
||||
def C.SHAPE_FLAG_SHIFT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_FLAG_SHIFT) }
|
||||
end
|
||||
|
||||
def C.SHAPE_FROZEN
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_FROZEN) }
|
||||
end
|
||||
|
||||
def C.SHAPE_ID_NUM_BITS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_ID_NUM_BITS) }
|
||||
end
|
||||
|
||||
def C.SHAPE_INITIAL_CAPACITY
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_INITIAL_CAPACITY) }
|
||||
end
|
||||
|
||||
def C.SHAPE_IVAR
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_IVAR) }
|
||||
end
|
||||
|
||||
def C.SHAPE_MASK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_MASK) }
|
||||
end
|
||||
|
||||
def C.SHAPE_ROOT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(SHAPE_ROOT) }
|
||||
end
|
||||
|
||||
def C.STRING_REDEFINED_OP_FLAG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(STRING_REDEFINED_OP_FLAG) }
|
||||
end
|
||||
|
||||
def C.T_OBJECT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(T_OBJECT) }
|
||||
end
|
||||
|
||||
def C.VM_BLOCK_HANDLER_NONE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_BLOCK_HANDLER_NONE) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_ARGS_BLOCKARG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_ARGS_BLOCKARG) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_ARGS_SPLAT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_ARGS_SPLAT) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_FCALL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_FCALL) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_KWARG
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KWARG) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_KW_SPLAT
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KW_SPLAT) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_KW_SPLAT_bit
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KW_SPLAT_bit) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_OPT_SEND
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_OPT_SEND) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_TAILCALL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_TAILCALL) }
|
||||
end
|
||||
|
||||
def C.VM_CALL_TAILCALL_bit
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_TAILCALL_bit) }
|
||||
end
|
||||
|
||||
def C.VM_ENV_DATA_INDEX_FLAGS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_DATA_INDEX_FLAGS) }
|
||||
end
|
||||
|
||||
def C.VM_ENV_DATA_SIZE
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_DATA_SIZE) }
|
||||
end
|
||||
|
||||
def C.VM_ENV_FLAG_LOCAL
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_FLAG_LOCAL) }
|
||||
end
|
||||
|
||||
def C.VM_ENV_FLAG_WB_REQUIRED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_FLAG_WB_REQUIRED) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_FLAG_BMETHOD
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_BMETHOD) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_FLAG_CFRAME
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_CFRAME) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_FLAG_CFRAME_KW
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_CFRAME_KW) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_FLAG_LAMBDA
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_LAMBDA) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_MAGIC_BLOCK
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_BLOCK) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_MAGIC_CFUNC
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_CFUNC) }
|
||||
end
|
||||
|
||||
def C.VM_FRAME_MAGIC_METHOD
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_METHOD) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_ALIAS
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ALIAS) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_ATTRSET
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ATTRSET) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_BMETHOD
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_BMETHOD) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_CFUNC
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_CFUNC) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_ISEQ
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ISEQ) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_IVAR
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_IVAR) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_MISSING
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_MISSING) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_NOTIMPLEMENTED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_NOTIMPLEMENTED) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_OPTIMIZED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_OPTIMIZED) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_REFINED
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_REFINED) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_UNDEF
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_UNDEF) }
|
||||
end
|
||||
|
||||
def C.VM_METHOD_TYPE_ZSUPER
|
||||
Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ZSUPER) }
|
||||
end
|
||||
C::ARRAY_REDEFINED_OP_FLAG = Primitive.cexpr! %q{ SIZET2NUM(ARRAY_REDEFINED_OP_FLAG) }
|
||||
C::BOP_AND = Primitive.cexpr! %q{ SIZET2NUM(BOP_AND) }
|
||||
C::BOP_AREF = Primitive.cexpr! %q{ SIZET2NUM(BOP_AREF) }
|
||||
C::BOP_EQ = Primitive.cexpr! %q{ SIZET2NUM(BOP_EQ) }
|
||||
C::BOP_FREEZE = Primitive.cexpr! %q{ SIZET2NUM(BOP_FREEZE) }
|
||||
C::BOP_GE = Primitive.cexpr! %q{ SIZET2NUM(BOP_GE) }
|
||||
C::BOP_GT = Primitive.cexpr! %q{ SIZET2NUM(BOP_GT) }
|
||||
C::BOP_LE = Primitive.cexpr! %q{ SIZET2NUM(BOP_LE) }
|
||||
C::BOP_LT = Primitive.cexpr! %q{ SIZET2NUM(BOP_LT) }
|
||||
C::BOP_MINUS = Primitive.cexpr! %q{ SIZET2NUM(BOP_MINUS) }
|
||||
C::BOP_MOD = Primitive.cexpr! %q{ SIZET2NUM(BOP_MOD) }
|
||||
C::BOP_OR = Primitive.cexpr! %q{ SIZET2NUM(BOP_OR) }
|
||||
C::BOP_PLUS = Primitive.cexpr! %q{ SIZET2NUM(BOP_PLUS) }
|
||||
C::HASH_REDEFINED_OP_FLAG = Primitive.cexpr! %q{ SIZET2NUM(HASH_REDEFINED_OP_FLAG) }
|
||||
C::INTEGER_REDEFINED_OP_FLAG = Primitive.cexpr! %q{ SIZET2NUM(INTEGER_REDEFINED_OP_FLAG) }
|
||||
C::INVALID_SHAPE_ID = Primitive.cexpr! %q{ SIZET2NUM(INVALID_SHAPE_ID) }
|
||||
C::METHOD_VISI_PRIVATE = Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PRIVATE) }
|
||||
C::METHOD_VISI_PROTECTED = Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PROTECTED) }
|
||||
C::METHOD_VISI_PUBLIC = Primitive.cexpr! %q{ SIZET2NUM(METHOD_VISI_PUBLIC) }
|
||||
C::OBJ_TOO_COMPLEX_SHAPE_ID = Primitive.cexpr! %q{ SIZET2NUM(OBJ_TOO_COMPLEX_SHAPE_ID) }
|
||||
C::OPTIMIZED_METHOD_TYPE_BLOCK_CALL = Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_BLOCK_CALL) }
|
||||
C::OPTIMIZED_METHOD_TYPE_CALL = Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_CALL) }
|
||||
C::OPTIMIZED_METHOD_TYPE_SEND = Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_SEND) }
|
||||
C::OPTIMIZED_METHOD_TYPE_STRUCT_AREF = Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_STRUCT_AREF) }
|
||||
C::OPTIMIZED_METHOD_TYPE_STRUCT_ASET = Primitive.cexpr! %q{ SIZET2NUM(OPTIMIZED_METHOD_TYPE_STRUCT_ASET) }
|
||||
C::RARRAY_EMBED_FLAG = Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_FLAG) }
|
||||
C::RARRAY_EMBED_LEN_MASK = Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_LEN_MASK) }
|
||||
C::RARRAY_EMBED_LEN_SHIFT = Primitive.cexpr! %q{ SIZET2NUM(RARRAY_EMBED_LEN_SHIFT) }
|
||||
C::RMODULE_IS_REFINEMENT = Primitive.cexpr! %q{ SIZET2NUM(RMODULE_IS_REFINEMENT) }
|
||||
C::ROBJECT_EMBED = Primitive.cexpr! %q{ SIZET2NUM(ROBJECT_EMBED) }
|
||||
C::RSTRUCT_EMBED_LEN_MASK = Primitive.cexpr! %q{ SIZET2NUM(RSTRUCT_EMBED_LEN_MASK) }
|
||||
C::RUBY_EVENT_CLASS = Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_CLASS) }
|
||||
C::RUBY_EVENT_C_CALL = Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_C_CALL) }
|
||||
C::RUBY_EVENT_C_RETURN = Primitive.cexpr! %q{ SIZET2NUM(RUBY_EVENT_C_RETURN) }
|
||||
C::RUBY_FIXNUM_FLAG = Primitive.cexpr! %q{ SIZET2NUM(RUBY_FIXNUM_FLAG) }
|
||||
C::RUBY_FLONUM_FLAG = Primitive.cexpr! %q{ SIZET2NUM(RUBY_FLONUM_FLAG) }
|
||||
C::RUBY_FLONUM_MASK = Primitive.cexpr! %q{ SIZET2NUM(RUBY_FLONUM_MASK) }
|
||||
C::RUBY_FL_SINGLETON = Primitive.cexpr! %q{ SIZET2NUM(RUBY_FL_SINGLETON) }
|
||||
C::RUBY_IMMEDIATE_MASK = Primitive.cexpr! %q{ SIZET2NUM(RUBY_IMMEDIATE_MASK) }
|
||||
C::RUBY_SPECIAL_SHIFT = Primitive.cexpr! %q{ SIZET2NUM(RUBY_SPECIAL_SHIFT) }
|
||||
C::RUBY_SYMBOL_FLAG = Primitive.cexpr! %q{ SIZET2NUM(RUBY_SYMBOL_FLAG) }
|
||||
C::RUBY_T_ARRAY = Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_ARRAY) }
|
||||
C::RUBY_T_ICLASS = Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_ICLASS) }
|
||||
C::RUBY_T_MASK = Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_MASK) }
|
||||
C::RUBY_T_MODULE = Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_MODULE) }
|
||||
C::RUBY_T_STRING = Primitive.cexpr! %q{ SIZET2NUM(RUBY_T_STRING) }
|
||||
C::SHAPE_CAPACITY_CHANGE = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_CAPACITY_CHANGE) }
|
||||
C::SHAPE_FLAG_SHIFT = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_FLAG_SHIFT) }
|
||||
C::SHAPE_FROZEN = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_FROZEN) }
|
||||
C::SHAPE_ID_NUM_BITS = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_ID_NUM_BITS) }
|
||||
C::SHAPE_INITIAL_CAPACITY = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_INITIAL_CAPACITY) }
|
||||
C::SHAPE_IVAR = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_IVAR) }
|
||||
C::SHAPE_MASK = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_MASK) }
|
||||
C::SHAPE_ROOT = Primitive.cexpr! %q{ SIZET2NUM(SHAPE_ROOT) }
|
||||
C::STRING_REDEFINED_OP_FLAG = Primitive.cexpr! %q{ SIZET2NUM(STRING_REDEFINED_OP_FLAG) }
|
||||
C::T_OBJECT = Primitive.cexpr! %q{ SIZET2NUM(T_OBJECT) }
|
||||
C::VM_BLOCK_HANDLER_NONE = Primitive.cexpr! %q{ SIZET2NUM(VM_BLOCK_HANDLER_NONE) }
|
||||
C::VM_CALL_ARGS_BLOCKARG = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_ARGS_BLOCKARG) }
|
||||
C::VM_CALL_ARGS_SPLAT = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_ARGS_SPLAT) }
|
||||
C::VM_CALL_FCALL = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_FCALL) }
|
||||
C::VM_CALL_KWARG = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KWARG) }
|
||||
C::VM_CALL_KW_SPLAT = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KW_SPLAT) }
|
||||
C::VM_CALL_KW_SPLAT_bit = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_KW_SPLAT_bit) }
|
||||
C::VM_CALL_OPT_SEND = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_OPT_SEND) }
|
||||
C::VM_CALL_TAILCALL = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_TAILCALL) }
|
||||
C::VM_CALL_TAILCALL_bit = Primitive.cexpr! %q{ SIZET2NUM(VM_CALL_TAILCALL_bit) }
|
||||
C::VM_ENV_DATA_INDEX_FLAGS = Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_DATA_INDEX_FLAGS) }
|
||||
C::VM_ENV_DATA_SIZE = Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_DATA_SIZE) }
|
||||
C::VM_ENV_FLAG_LOCAL = Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_FLAG_LOCAL) }
|
||||
C::VM_ENV_FLAG_WB_REQUIRED = Primitive.cexpr! %q{ SIZET2NUM(VM_ENV_FLAG_WB_REQUIRED) }
|
||||
C::VM_FRAME_FLAG_BMETHOD = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_BMETHOD) }
|
||||
C::VM_FRAME_FLAG_CFRAME = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_CFRAME) }
|
||||
C::VM_FRAME_FLAG_CFRAME_KW = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_CFRAME_KW) }
|
||||
C::VM_FRAME_FLAG_LAMBDA = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_LAMBDA) }
|
||||
C::VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM) }
|
||||
C::VM_FRAME_MAGIC_BLOCK = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_BLOCK) }
|
||||
C::VM_FRAME_MAGIC_CFUNC = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_CFUNC) }
|
||||
C::VM_FRAME_MAGIC_METHOD = Primitive.cexpr! %q{ SIZET2NUM(VM_FRAME_MAGIC_METHOD) }
|
||||
C::VM_METHOD_TYPE_ALIAS = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ALIAS) }
|
||||
C::VM_METHOD_TYPE_ATTRSET = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ATTRSET) }
|
||||
C::VM_METHOD_TYPE_BMETHOD = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_BMETHOD) }
|
||||
C::VM_METHOD_TYPE_CFUNC = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_CFUNC) }
|
||||
C::VM_METHOD_TYPE_ISEQ = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ISEQ) }
|
||||
C::VM_METHOD_TYPE_IVAR = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_IVAR) }
|
||||
C::VM_METHOD_TYPE_MISSING = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_MISSING) }
|
||||
C::VM_METHOD_TYPE_NOTIMPLEMENTED = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_NOTIMPLEMENTED) }
|
||||
C::VM_METHOD_TYPE_OPTIMIZED = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_OPTIMIZED) }
|
||||
C::VM_METHOD_TYPE_REFINED = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_REFINED) }
|
||||
C::VM_METHOD_TYPE_UNDEF = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_UNDEF) }
|
||||
C::VM_METHOD_TYPE_ZSUPER = Primitive.cexpr! %q{ SIZET2NUM(VM_METHOD_TYPE_ZSUPER) }
|
||||
|
||||
def C.block_type_iseq
|
||||
Primitive.cexpr! %q{ SIZET2NUM(block_type_iseq) }
|
||||
|
|
|
|||
|
|
@ -368,8 +368,6 @@ generator = BindingGenerator.new(
|
|||
VM_ENV_DATA_INDEX_ME_CREF
|
||||
VM_ENV_DATA_INDEX_SPECVAL
|
||||
],
|
||||
},
|
||||
values: {
|
||||
SIZET: %w[
|
||||
ARRAY_REDEFINED_OP_FLAG
|
||||
BOP_AND
|
||||
|
|
@ -461,6 +459,10 @@ generator = BindingGenerator.new(
|
|||
VM_METHOD_TYPE_REFINED
|
||||
VM_METHOD_TYPE_UNDEF
|
||||
VM_METHOD_TYPE_ZSUPER
|
||||
],
|
||||
},
|
||||
values: {
|
||||
SIZET: %w[
|
||||
block_type_iseq
|
||||
imemo_iseq
|
||||
rb_block_param_proxy
|
||||
|
|
@ -516,8 +518,8 @@ generator = BindingGenerator.new(
|
|||
IC
|
||||
ID
|
||||
IVC
|
||||
RB_BUILTIN
|
||||
RArray
|
||||
RB_BUILTIN
|
||||
RBasic
|
||||
RObject
|
||||
RStruct
|
||||
|
|
@ -526,14 +528,16 @@ generator = BindingGenerator.new(
|
|||
iseq_inline_constant_cache_entry
|
||||
iseq_inline_iv_cache_entry
|
||||
iseq_inline_storage_entry
|
||||
rjit_options
|
||||
method_optimized_type
|
||||
rb_block
|
||||
rb_block_type
|
||||
rb_builtin_function
|
||||
rb_call_data
|
||||
rb_callable_method_entry_struct
|
||||
rb_callable_method_entry_t
|
||||
rb_method_entry_t
|
||||
rb_callcache
|
||||
rb_callinfo
|
||||
rb_captured_block
|
||||
rb_control_frame_t
|
||||
rb_cref_t
|
||||
rb_execution_context_struct
|
||||
|
|
@ -542,24 +546,23 @@ generator = BindingGenerator.new(
|
|||
rb_iseq_location_t
|
||||
rb_iseq_struct
|
||||
rb_iseq_t
|
||||
rb_method_definition_struct
|
||||
rb_method_iseq_t
|
||||
rb_method_type_t
|
||||
rb_method_attr_t
|
||||
rb_method_bmethod_t
|
||||
rb_method_cfunc_t
|
||||
rb_method_definition_struct
|
||||
rb_method_entry_t
|
||||
rb_method_iseq_t
|
||||
rb_method_optimized_t
|
||||
rb_method_type_t
|
||||
rb_proc_t
|
||||
rb_rjit_runtime_counters
|
||||
rb_serial_t
|
||||
rb_shape
|
||||
rb_shape_t
|
||||
rb_method_attr_t
|
||||
rb_method_cfunc_t
|
||||
rb_method_optimized_t
|
||||
method_optimized_type
|
||||
rb_thread_struct
|
||||
rb_proc_t
|
||||
rb_block
|
||||
rb_block_type
|
||||
rb_captured_block
|
||||
rjit_options
|
||||
],
|
||||
# #ifdef-dependent immediate types, which need Primitive.cexpr! for type detection
|
||||
dynamic_types: %w[
|
||||
VALUE
|
||||
shape_id_t
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче