diff options
author | Takashi Kokubun <takashikkbn@gmail.com> | 2023-03-11 21:54:09 -0800 |
---|---|---|
committer | Takashi Kokubun <takashikkbn@gmail.com> | 2023-03-11 22:04:30 -0800 |
commit | fe34db5a1bc7053ec737ac5d197fa22d54f64b12 (patch) | |
tree | 995af8c1612b526265861c66e422892995a61e61 /lib | |
parent | 50c5f94ed71707030f03ef1ce699367f021e0aa3 (diff) | |
download | ruby-fe34db5a1bc7053ec737ac5d197fa22d54f64b12.tar.gz |
RJIT: Migrate SIZET values to RJIT::C constants
Diffstat (limited to 'lib')
-rw-r--r-- | lib/ruby_vm/rjit/insn_compiler.rb | 278 |
1 files changed, 139 insertions, 139 deletions
diff --git a/lib/ruby_vm/rjit/insn_compiler.rb b/lib/ruby_vm/rjit/insn_compiler.rb index 162b8c2eb5..6fe1458281 100644 --- a/lib/ruby_vm/rjit/insn_compiler.rb +++ b/lib/ruby_vm/rjit/insn_compiler.rb @@ -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] |