From 1a991131a04feb3527f7e4993491b587d2e57179 Mon Sep 17 00:00:00 2001 From: Takashi Kokubun Date: Thu, 5 Jun 2025 14:48:04 -0700 Subject: [PATCH] ZJIT: Pass self through basic block params (#13529) * ZJIT: Pass self through basic block params Co-authored-by: Max Bernstein * Add comments for self * Use self_param for ivar * Make self_param a loop local * Fix rest parameter type check * Push self_param first * Add a test case for putself * Use SELF_PARAM_IDX Co-authored-by: Max Bernstein * Fix test_unknown --------- Co-authored-by: Max Bernstein --- test/ruby/test_zjit.rb | 11 + zjit/src/backend/arm64/mod.rs | 4 +- zjit/src/backend/lir.rs | 4 +- zjit/src/codegen.rs | 29 +- zjit/src/hir.rs | 1141 ++++++++++++++++----------------- 5 files changed, 586 insertions(+), 603 deletions(-) diff --git a/test/ruby/test_zjit.rb b/test/ruby/test_zjit.rb index 3d97c92a02..d6fc4ba2f7 100644 --- a/test/ruby/test_zjit.rb +++ b/test/ruby/test_zjit.rb @@ -534,6 +534,17 @@ class TestZJIT < Test::Unit::TestCase } end + def test_putself + assert_compiles '3', %q{ + class Integer + def minus(a) + self - a + end + end + 5.minus(2) + } + end + # tool/ruby_vm/views/*.erb relies on the zjit instructions a) being contiguous and # b) being reliably ordered after all the other instructions. def test_instruction_order diff --git a/zjit/src/backend/arm64/mod.rs b/zjit/src/backend/arm64/mod.rs index 832f3c1e1e..f7e871523e 100644 --- a/zjit/src/backend/arm64/mod.rs +++ b/zjit/src/backend/arm64/mod.rs @@ -641,7 +641,7 @@ impl Assembler }, // If we're loading a memory operand into a register, then // we'll switch over to the load instruction. - (Opnd::Reg(_), Opnd::Mem(_)) => { + (Opnd::Reg(_) | Opnd::VReg { .. }, Opnd::Mem(_)) => { let value = split_memory_address(asm, *src); asm.load_into(*dest, value); }, @@ -654,7 +654,7 @@ impl Assembler }; asm.mov(*dest, value); }, - _ => unreachable!() + _ => unreachable!("unexpected combination of operands in Insn::Mov: {dest:?}, {src:?}") }; }, Insn::Not { opnd, .. } => { diff --git a/zjit/src/backend/lir.rs b/zjit/src/backend/lir.rs index 3a85e3cfb5..e9ae8730f6 100644 --- a/zjit/src/backend/lir.rs +++ b/zjit/src/backend/lir.rs @@ -77,7 +77,7 @@ impl fmt::Debug for Opnd { match self { Self::None => write!(fmt, "None"), Value(val) => write!(fmt, "Value({val:?})"), - VReg { idx, num_bits } => write!(fmt, "Out{num_bits}({idx})"), + VReg { idx, num_bits } => write!(fmt, "VReg{num_bits}({idx})"), Imm(signed) => write!(fmt, "{signed:x}_i64"), UImm(unsigned) => write!(fmt, "{unsigned:x}_u64"), // Say Mem and Reg only once @@ -1122,7 +1122,7 @@ impl RegisterPool { fn take_reg(&mut self, reg: &Reg, vreg_idx: usize) -> Reg { let reg_idx = self.regs.iter().position(|elem| elem.reg_no == reg.reg_no) .unwrap_or_else(|| panic!("Unable to find register: {}", reg.reg_no)); - assert_eq!(self.pool[reg_idx], None, "register already allocated"); + assert_eq!(self.pool[reg_idx], None, "register already allocated for VReg({:?})", self.pool[reg_idx]); self.pool[reg_idx] = Some(vreg_idx); self.live_regs += 1; *reg diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs index c8713bb612..221f5fc3f9 100644 --- a/zjit/src/codegen.rs +++ b/zjit/src/codegen.rs @@ -7,7 +7,7 @@ use crate::state::ZJITState; use crate::{asm::CodeBlock, cruby::*, options::debug, virtualmem::CodePtr}; use crate::invariants::{iseq_escapes_ep, track_no_ep_escape_assumption}; use crate::backend::lir::{self, asm_comment, Assembler, Opnd, Target, CFP, C_ARG_OPNDS, C_RET_OPND, EC, SP}; -use crate::hir::{iseq_to_hir, Block, BlockId, BranchEdge, CallInfo, RangeType}; +use crate::hir::{iseq_to_hir, Block, BlockId, BranchEdge, CallInfo, RangeType, SELF_PARAM_IDX}; use crate::hir::{Const, FrameState, Function, Insn, InsnId}; use crate::hir_type::{types::Fixnum, Type}; use crate::options::get_option; @@ -248,7 +248,6 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio } let out_opnd = match insn { - Insn::PutSelf => gen_putself(), Insn::Const { val: Const::Value(val) } => gen_const(*val), Insn::NewArray { elements, state } => gen_new_array(jit, asm, elements, &function.frame_state(*state)), Insn::NewRange { low, high, flag, state } => gen_new_range(asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)), @@ -324,13 +323,16 @@ fn gen_entry_prologue(asm: &mut Assembler, iseq: IseqPtr) { /// Assign method arguments to basic block arguments at JIT entry fn gen_method_params(asm: &mut Assembler, iseq: IseqPtr, entry_block: &Block) { + let self_param = gen_param(asm, SELF_PARAM_IDX); + asm.mov(self_param, Opnd::mem(VALUE_BITS, CFP, RUBY_OFFSET_CFP_SELF)); + let num_params = entry_block.params().len(); if num_params > 0 { asm_comment!(asm, "set method params: {num_params}"); // Allocate registers for basic block arguments let params: Vec = (0..num_params).map(|idx| - gen_param(asm, idx) + gen_param(asm, idx + 1) // +1 for self ).collect(); // Assign local variables to the basic block arguments @@ -374,11 +376,6 @@ fn gen_getlocal(asm: &mut Assembler, iseq: IseqPtr, local_idx: usize) -> lir::Op } } -/// Compile self in the current frame -fn gen_putself() -> lir::Opnd { - Opnd::mem(VALUE_BITS, CFP, RUBY_OFFSET_CFP_SELF) -} - /// Compile a constant fn gen_const(val: VALUE) -> lir::Opnd { // Just propagate the constant value and generate nothing @@ -482,9 +479,6 @@ fn gen_send_without_block_direct( recv: Opnd, args: &Vec, ) -> Option { - // Set up the new frame - gen_push_frame(asm, recv); - asm_comment!(asm, "switch to new CFP"); let new_cfp = asm.sub(CFP, RUBY_SIZEOF_CONTROL_FRAME.into()); asm.mov(CFP, new_cfp); @@ -492,6 +486,7 @@ fn gen_send_without_block_direct( // Set up arguments let mut c_args: Vec = vec![]; + c_args.push(recv); for &arg in args.iter() { c_args.push(jit.get_opnd(arg)?); } @@ -714,18 +709,6 @@ fn gen_save_sp(asm: &mut Assembler, stack_size: usize) { asm.mov(cfp_sp, sp_addr); } -/// Compile an interpreter frame -fn gen_push_frame(asm: &mut Assembler, recv: Opnd) { - // Write to a callee CFP - fn cfp_opnd(offset: i32) -> Opnd { - Opnd::mem(64, CFP, offset - (RUBY_SIZEOF_CONTROL_FRAME as i32)) - } - - asm_comment!(asm, "push callee control frame"); - asm.mov(cfp_opnd(RUBY_OFFSET_CFP_SELF), recv); - // TODO: Write more fields as needed -} - /// Return a register we use for the basic block argument at a given index fn param_reg(idx: usize) -> Reg { // To simplify the implementation, allocate a fixed register for each basic block argument for now. diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs index 746a3b7e9a..9e27dc3182 100644 --- a/zjit/src/hir.rs +++ b/zjit/src/hir.rs @@ -358,7 +358,6 @@ impl PtrPrintMap { /// helps with editing. #[derive(Debug, Clone)] pub enum Insn { - PutSelf, Const { val: Const }, /// SSA block parameter. Also used for function parameters in the function's entry block. Param { idx: usize }, @@ -478,7 +477,6 @@ impl Insn { /// might have a side effect, or if the instruction may raise an exception. fn has_effects(&self) -> bool { match self { - Insn::PutSelf => false, Insn::Const { .. } => false, Insn::Param { .. } => false, Insn::StringCopy { .. } => false, @@ -892,7 +890,7 @@ impl Function { let insn_id = find!(insn_id); use Insn::*; match &self.insns[insn_id.0] { - result@(PutSelf | Const {..} | Param {..} | GetConstantPath {..} + result@(Const {..} | Param {..} | GetConstantPath {..} | PatchPoint {..}) => result.clone(), Snapshot { state: FrameState { iseq, insn_idx, pc, stack, locals } } => Snapshot { @@ -1040,7 +1038,6 @@ impl Function { Insn::SendWithoutBlock { .. } => types::BasicObject, Insn::SendWithoutBlockDirect { .. } => types::BasicObject, Insn::Send { .. } => types::BasicObject, - Insn::PutSelf => types::BasicObject, Insn::Defined { .. } => types::BasicObject, Insn::GetConstantPath { .. } => types::BasicObject, Insn::ArrayMax { .. } => types::BasicObject, @@ -1522,7 +1519,7 @@ impl Function { if necessary[insn_id.0] { continue; } necessary[insn_id.0] = true; match self.find(insn_id) { - Insn::PutSelf | Insn::Const { .. } | Insn::Param { .. } + Insn::Const { .. } | Insn::Param { .. } | Insn::PatchPoint(..) | Insn::GetConstantPath { .. } => {} Insn::ArrayMax { elements, state } @@ -1817,8 +1814,16 @@ impl FrameState { self.locals[idx] } - fn as_args(&self) -> Vec { - self.locals.iter().chain(self.stack.iter()).map(|op| *op).collect() + fn as_args(&self, self_param: InsnId) -> Vec { + // We're currently passing around the self parameter as a basic block + // argument because the register allocator uses a fixed register based + // on the basic block argument index, which would cause a conflict if + // we reuse an argument from another basic block. + // TODO: Modify the register allocator to allow reusing an argument + // of another basic block. + let mut args = vec![self_param]; + args.extend(self.locals.iter().chain(self.stack.iter()).map(|op| *op)); + args } } @@ -1950,6 +1955,9 @@ impl ProfileOracle { } } +/// The index of the self parameter in the HIR function +pub const SELF_PARAM_IDX: usize = 0; + /// Compile ISEQ into High-level IR pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let payload = get_or_create_iseq_payload(iseq); @@ -1981,16 +1989,18 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { // item between commas in the source increase the parameter count by one, // regardless of parameter kind. let mut entry_state = FrameState::new(iseq); - for idx in 0..num_locals(iseq) { - if idx < unsafe { get_iseq_body_param_size(iseq) }.as_usize() { - entry_state.locals.push(fun.push_insn(fun.entry_block, Insn::Param { idx })); + fun.push_insn(fun.entry_block, Insn::Param { idx: SELF_PARAM_IDX }); + fun.param_types.push(types::BasicObject); // self + for local_idx in 0..num_locals(iseq) { + if local_idx < unsafe { get_iseq_body_param_size(iseq) }.as_usize() { + entry_state.locals.push(fun.push_insn(fun.entry_block, Insn::Param { idx: local_idx + 1 })); // +1 for self } else { entry_state.locals.push(fun.push_insn(fun.entry_block, Insn::Const { val: Const::Value(Qnil) })); } let mut param_type = types::BasicObject; // Rest parameters are always ArrayExact - if let Ok(true) = c_int::try_from(idx).map(|idx| idx == rest_param_idx) { + if let Ok(true) = c_int::try_from(local_idx).map(|idx| idx == rest_param_idx) { param_type = types::ArrayExact; } fun.param_types.push(param_type); @@ -2003,9 +2013,12 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { while let Some((incoming_state, block, mut insn_idx)) = queue.pop_front() { if visited.contains(&block) { continue; } visited.insert(block); - let mut state = if insn_idx == 0 { incoming_state.clone() } else { + let (self_param, mut state) = if insn_idx == 0 { + (fun.blocks[fun.entry_block.0].params[SELF_PARAM_IDX], incoming_state.clone()) + } else { + let self_param = fun.push_insn(block, Insn::Param { idx: SELF_PARAM_IDX }); let mut result = FrameState::new(iseq); - let mut idx = 0; + let mut idx = 1; for _ in 0..incoming_state.locals.len() { result.locals.push(fun.push_insn(block, Insn::Param { idx })); idx += 1; @@ -2014,7 +2027,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { result.stack.push(fun.push_insn(block, Insn::Param { idx })); idx += 1; } - result + (self_param, result) }; // Start the block off with a Snapshot so that if we need to insert a new Guard later on // and we don't have a Snapshot handy, we can just iterate backward (at the earliest, to @@ -2045,7 +2058,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let insn_id = fun.push_insn(block, Insn::StringCopy { val }); state.stack_push(insn_id); } - YARVINSN_putself => { state.stack_push(fun.push_insn(block, Insn::PutSelf)); } + YARVINSN_putself => { state.stack_push(self_param); } YARVINSN_intern => { let val = state.stack_pop()?; let insn_id = fun.push_insn(block, Insn::StringIntern { val }); @@ -2165,7 +2178,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let target = insn_idx_to_block[&target_idx]; let _branch_id = fun.push_insn(block, Insn::IfFalse { val: test_id, - target: BranchEdge { target, args: state.as_args() } + target: BranchEdge { target, args: state.as_args(self_param) } }); queue.push_back((state.clone(), target, target_idx)); } @@ -2178,7 +2191,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let target = insn_idx_to_block[&target_idx]; let _branch_id = fun.push_insn(block, Insn::IfTrue { val: test_id, - target: BranchEdge { target, args: state.as_args() } + target: BranchEdge { target, args: state.as_args(self_param) } }); queue.push_back((state.clone(), target, target_idx)); } @@ -2191,7 +2204,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let target = insn_idx_to_block[&target_idx]; let _branch_id = fun.push_insn(block, Insn::IfTrue { val: test_id, - target: BranchEdge { target, args: state.as_args() } + target: BranchEdge { target, args: state.as_args(self_param) } }); queue.push_back((state.clone(), target, target_idx)); } @@ -2202,7 +2215,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let target = insn_idx_to_block[&target_idx]; // Skip the fast-path and go straight to the fallback code. We will let the // optimizer take care of the converting Class#new->alloc+initialize instead. - fun.push_insn(block, Insn::Jump(BranchEdge { target, args: state.as_args() })); + fun.push_insn(block, Insn::Jump(BranchEdge { target, args: state.as_args(self_param) })); queue.push_back((state.clone(), target, target_idx)); break; // Don't enqueue the next block as a successor } @@ -2212,7 +2225,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let target_idx = insn_idx_at_offset(insn_idx, offset); let target = insn_idx_to_block[&target_idx]; let _branch_id = fun.push_insn(block, Insn::Jump( - BranchEdge { target, args: state.as_args() } + BranchEdge { target, args: state.as_args(self_param) } )); queue.push_back((state.clone(), target, target_idx)); break; // Don't enqueue the next block as a successor @@ -2386,17 +2399,15 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { let id = ID(get_arg(pc, 0).as_u64()); // ic is in arg 1 let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state }); - let self_val = fun.push_insn(block, Insn::PutSelf); - let result = fun.push_insn(block, Insn::GetIvar { self_val, id, state: exit_id }); + let result = fun.push_insn(block, Insn::GetIvar { self_val: self_param, id, state: exit_id }); state.stack_push(result); } YARVINSN_setinstancevariable => { let id = ID(get_arg(pc, 0).as_u64()); // ic is in arg 1 let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state }); - let self_val = fun.push_insn(block, Insn::PutSelf); let val = state.stack_pop()?; - fun.push_insn(block, Insn::SetIvar { self_val, id, val, state: exit_id }); + fun.push_insn(block, Insn::SetIvar { self_val: self_param, id, val, state: exit_id }); } YARVINSN_newrange => { let flag = RangeType::from(get_arg(pc, 0).as_u32()); @@ -2416,7 +2427,7 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result { if insn_idx_to_block.contains_key(&insn_idx) { let target = insn_idx_to_block[&insn_idx]; - fun.push_insn(block, Insn::Jump(BranchEdge { target, args: state.as_args() })); + fun.push_insn(block, Insn::Jump(BranchEdge { target, args: state.as_args(self_param) })); queue.push_back((state, target, insn_idx)); break; // End the block } @@ -2594,7 +2605,8 @@ mod infer_tests { fn test_unknown() { crate::cruby::with_rubyvm(|| { let mut function = Function::new(std::ptr::null()); - let param = function.push_insn(function.entry_block, Insn::PutSelf); + let param = function.push_insn(function.entry_block, Insn::Param { idx: SELF_PARAM_IDX }); + function.param_types.push(types::BasicObject); // self let val = function.push_insn(function.entry_block, Insn::Test { val: param }); function.infer_types(); assert_bit_equal(function.type_of(val), types::CBool); @@ -2760,9 +2772,9 @@ mod tests { eval("def test = 123"); assert_method_hir_with_opcode("test", YARVINSN_putobject, expect![[r#" fn test: - bb0(): - v1:Fixnum[123] = Const Value(123) - Return v1 + bb0(v0:BasicObject): + v2:Fixnum[123] = Const Value(123) + Return v2 "#]]); } @@ -2771,9 +2783,9 @@ mod tests { eval("def test = []"); assert_method_hir_with_opcode("test", YARVINSN_newarray, expect![[r#" fn test: - bb0(): - v2:ArrayExact = NewArray - Return v2 + bb0(v0:BasicObject): + v3:ArrayExact = NewArray + Return v3 "#]]); } @@ -2782,9 +2794,9 @@ mod tests { eval("def test(a) = [a]"); assert_method_hir_with_opcode("test", YARVINSN_newarray, expect![[r#" fn test: - bb0(v0:BasicObject): - v3:ArrayExact = NewArray v0 - Return v3 + bb0(v0:BasicObject, v1:BasicObject): + v4:ArrayExact = NewArray v1 + Return v4 "#]]); } @@ -2793,9 +2805,9 @@ mod tests { eval("def test(a, b) = [a, b]"); assert_method_hir_with_opcode("test", YARVINSN_newarray, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:ArrayExact = NewArray v0, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:ArrayExact = NewArray v1, v2 + Return v5 "#]]); } @@ -2804,10 +2816,10 @@ mod tests { eval("def test(a) = (a..10)"); assert_method_hir_with_opcode("test", YARVINSN_newrange, expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[10] = Const Value(10) - v4:RangeExact = NewRange v0 NewRangeInclusive v2 - Return v4 + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[10] = Const Value(10) + v5:RangeExact = NewRange v1 NewRangeInclusive v3 + Return v5 "#]]); } @@ -2816,9 +2828,9 @@ mod tests { eval("def test(a, b) = (a..b)"); assert_method_hir_with_opcode("test", YARVINSN_newrange, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:RangeExact = NewRange v0 NewRangeInclusive v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:RangeExact = NewRange v1 NewRangeInclusive v2 + Return v5 "#]]); } @@ -2827,10 +2839,10 @@ mod tests { eval("def test(a) = (a...10)"); assert_method_hir_with_opcode("test", YARVINSN_newrange, expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[10] = Const Value(10) - v4:RangeExact = NewRange v0 NewRangeExclusive v2 - Return v4 + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[10] = Const Value(10) + v5:RangeExact = NewRange v1 NewRangeExclusive v3 + Return v5 "#]]); } @@ -2839,9 +2851,9 @@ mod tests { eval("def test(a, b) = (a...b)"); assert_method_hir_with_opcode("test", YARVINSN_newrange, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:RangeExact = NewRange v0 NewRangeExclusive v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:RangeExact = NewRange v1 NewRangeExclusive v2 + Return v5 "#]]); } @@ -2850,10 +2862,10 @@ mod tests { eval("def test = [1, 2, 3]"); assert_method_hir_with_opcode("test", YARVINSN_duparray, expect![[r#" fn test: - bb0(): - v1:ArrayExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v3:ArrayExact = ArrayDup v1 - Return v3 + bb0(v0:BasicObject): + v2:ArrayExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v4:ArrayExact = ArrayDup v2 + Return v4 "#]]); } @@ -2862,10 +2874,10 @@ mod tests { eval("def test = {a: 1, b: 2}"); assert_method_hir_with_opcode("test", YARVINSN_duphash, expect![[r#" fn test: - bb0(): - v1:HashExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v3:HashExact = HashDup v1 - Return v3 + bb0(v0:BasicObject): + v2:HashExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v4:HashExact = HashDup v2 + Return v4 "#]]); } @@ -2874,9 +2886,9 @@ mod tests { eval("def test = {}"); assert_method_hir_with_opcode("test", YARVINSN_newhash, expect![[r#" fn test: - bb0(): - v2:HashExact = NewHash - Return v2 + bb0(v0:BasicObject): + v3:HashExact = NewHash + Return v3 "#]]); } @@ -2885,11 +2897,11 @@ mod tests { eval("def test(aval, bval) = {a: aval, b: bval}"); assert_method_hir_with_opcode("test", YARVINSN_newhash, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v3:StaticSymbol[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v4:StaticSymbol[VALUE(0x1008)] = Const Value(VALUE(0x1008)) - v6:HashExact = NewHash v3: v0, v4: v1 - Return v6 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v4:StaticSymbol[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v5:StaticSymbol[VALUE(0x1008)] = Const Value(VALUE(0x1008)) + v7:HashExact = NewHash v4: v1, v5: v2 + Return v7 "#]]); } @@ -2898,10 +2910,10 @@ mod tests { eval("def test = \"hello\""); assert_method_hir_with_opcode("test", YARVINSN_putchilledstring, expect![[r#" fn test: - bb0(): - v1:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v2:StringExact = StringCopy v1 - Return v2 + bb0(v0:BasicObject): + v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v3:StringExact = StringCopy v2 + Return v3 "#]]); } @@ -2910,9 +2922,9 @@ mod tests { eval("def test = 999999999999999999999999999999999999"); assert_method_hir_with_opcode("test", YARVINSN_putobject, expect![[r#" fn test: - bb0(): - v1:Bignum[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - Return v1 + bb0(v0:BasicObject): + v2:Bignum[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + Return v2 "#]]); } @@ -2921,9 +2933,9 @@ mod tests { eval("def test = 1.5"); assert_method_hir_with_opcode("test", YARVINSN_putobject, expect![[r#" fn test: - bb0(): - v1:Flonum[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - Return v1 + bb0(v0:BasicObject): + v2:Flonum[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + Return v2 "#]]); } @@ -2932,9 +2944,9 @@ mod tests { eval("def test = 1.7976931348623157e+308"); assert_method_hir_with_opcode("test", YARVINSN_putobject, expect![[r#" fn test: - bb0(): - v1:HeapFloat[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - Return v1 + bb0(v0:BasicObject): + v2:HeapFloat[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + Return v2 "#]]); } @@ -2943,9 +2955,9 @@ mod tests { eval("def test = :foo"); assert_method_hir_with_opcode("test", YARVINSN_putobject, expect![[r#" fn test: - bb0(): - v1:StaticSymbol[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - Return v1 + bb0(v0:BasicObject): + v2:StaticSymbol[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + Return v2 "#]]); } @@ -2954,11 +2966,11 @@ mod tests { eval("def test = 1+2"); assert_method_hir_with_opcode("test", YARVINSN_opt_plus, expect![[r#" fn test: - bb0(): - v1:Fixnum[1] = Const Value(1) - v2:Fixnum[2] = Const Value(2) - v4:BasicObject = SendWithoutBlock v1, :+, v2 - Return v4 + bb0(v0:BasicObject): + v2:Fixnum[1] = Const Value(1) + v3:Fixnum[2] = Const Value(2) + v5:BasicObject = SendWithoutBlock v2, :+, v3 + Return v5 "#]]); } @@ -2972,10 +2984,10 @@ mod tests { "); assert_method_hir_with_opcodes("test", vec![YARVINSN_getlocal_WC_0, YARVINSN_setlocal_WC_0], expect![[r#" fn test: - bb0(): - v0:NilClassExact = Const Value(nil) - v2:Fixnum[1] = Const Value(1) - Return v2 + bb0(v0:BasicObject): + v1:NilClassExact = Const Value(nil) + v3:Fixnum[1] = Const Value(1) + Return v3 "#]]); } @@ -2992,14 +3004,14 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_leave, expect![[r#" fn test: - bb0(v0:BasicObject): - v2:CBool = Test v0 - IfFalse v2, bb1(v0) - v4:Fixnum[3] = Const Value(3) - Return v4 - bb1(v6:BasicObject): - v8:Fixnum[4] = Const Value(4) - Return v8 + bb0(v0:BasicObject, v1:BasicObject): + v3:CBool = Test v1 + IfFalse v3, bb1(v0, v1) + v5:Fixnum[3] = Const Value(3) + Return v5 + bb1(v7:BasicObject, v8:BasicObject): + v10:Fixnum[4] = Const Value(4) + Return v10 "#]]); } @@ -3017,17 +3029,17 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v1:NilClassExact = Const Value(nil) - v3:CBool = Test v0 - IfFalse v3, bb1(v0, v1) - v5:Fixnum[3] = Const Value(3) - Jump bb2(v0, v5) - bb1(v7:BasicObject, v8:NilClassExact): - v10:Fixnum[4] = Const Value(4) - Jump bb2(v7, v10) - bb2(v12:BasicObject, v13:Fixnum): - Return v13 + bb0(v0:BasicObject, v1:BasicObject): + v2:NilClassExact = Const Value(nil) + v4:CBool = Test v1 + IfFalse v4, bb1(v0, v1, v2) + v6:Fixnum[3] = Const Value(3) + Jump bb2(v0, v1, v6) + bb1(v8:BasicObject, v9:BasicObject, v10:NilClassExact): + v12:Fixnum[4] = Const Value(4) + Jump bb2(v8, v9, v12) + bb2(v14:BasicObject, v15:BasicObject, v16:Fixnum): + Return v16 "#]]); } @@ -3039,9 +3051,9 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :+, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :+, v2 + Return v5 "#]]); } @@ -3053,9 +3065,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_minus, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :-, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :-, v2 + Return v5 "#]]); } @@ -3067,9 +3079,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_mult, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :*, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :*, v2 + Return v5 "#]]); } @@ -3081,9 +3093,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_div, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :/, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :/, v2 + Return v5 "#]]); } @@ -3095,9 +3107,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_mod, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :%, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :%, v2 + Return v5 "#]]); } @@ -3109,9 +3121,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_eq, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :==, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :==, v2 + Return v5 "#]]); } @@ -3123,9 +3135,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_neq, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :!=, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :!=, v2 + Return v5 "#]]); } @@ -3137,9 +3149,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_lt, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :<, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :<, v2 + Return v5 "#]]); } @@ -3151,9 +3163,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_le, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :<=, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :<=, v2 + Return v5 "#]]); } @@ -3165,9 +3177,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_gt, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :>, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :>, v2 + Return v5 "#]]); } @@ -3187,25 +3199,25 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(): - v0:NilClassExact = Const Value(nil) + bb0(v0:BasicObject): v1:NilClassExact = Const Value(nil) - v3:Fixnum[0] = Const Value(0) - v4:Fixnum[10] = Const Value(10) - Jump bb2(v3, v4) - bb2(v6:BasicObject, v7:BasicObject): - v9:Fixnum[0] = Const Value(0) - v11:BasicObject = SendWithoutBlock v7, :>, v9 - v12:CBool = Test v11 - IfTrue v12, bb1(v6, v7) - v14:NilClassExact = Const Value(nil) - Return v6 - bb1(v16:BasicObject, v17:BasicObject): - v19:Fixnum[1] = Const Value(1) - v21:BasicObject = SendWithoutBlock v16, :+, v19 + v2:NilClassExact = Const Value(nil) + v4:Fixnum[0] = Const Value(0) + v5:Fixnum[10] = Const Value(10) + Jump bb2(v0, v4, v5) + bb2(v7:BasicObject, v8:BasicObject, v9:BasicObject): + v11:Fixnum[0] = Const Value(0) + v13:BasicObject = SendWithoutBlock v9, :>, v11 + v14:CBool = Test v13 + IfTrue v14, bb1(v7, v8, v9) + v16:NilClassExact = Const Value(nil) + Return v8 + bb1(v18:BasicObject, v19:BasicObject, v20:BasicObject): v22:Fixnum[1] = Const Value(1) - v24:BasicObject = SendWithoutBlock v17, :-, v22 - Jump bb2(v21, v24) + v24:BasicObject = SendWithoutBlock v19, :+, v22 + v25:Fixnum[1] = Const Value(1) + v27:BasicObject = SendWithoutBlock v20, :-, v25 + Jump bb2(v18, v24, v27) "#]]); } @@ -3217,9 +3229,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_ge, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :>=, v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :>=, v2 + Return v5 "#]]); } @@ -3237,16 +3249,16 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(): - v0:NilClassExact = Const Value(nil) - v2:TrueClassExact = Const Value(true) - v3:CBool[true] = Test v2 - IfFalse v3, bb1(v2) - v5:Fixnum[3] = Const Value(3) - Return v5 - bb1(v7): - v9 = Const Value(4) - Return v9 + bb0(v0:BasicObject): + v1:NilClassExact = Const Value(nil) + v3:TrueClassExact = Const Value(true) + v4:CBool[true] = Test v3 + IfFalse v4, bb1(v0, v3) + v6:Fixnum[3] = Const Value(3) + Return v6 + bb1(v8, v9): + v11 = Const Value(4) + Return v11 "#]]); } @@ -3262,11 +3274,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_send_without_block, expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): v2:Fixnum[2] = Const Value(2) v3:Fixnum[3] = Const Value(3) - v5:BasicObject = SendWithoutBlock v1, :bar, v2, v3 + v5:BasicObject = SendWithoutBlock v0, :bar, v2, v3 Return v5 "#]]); } @@ -3283,9 +3294,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_send, expect![[r#" fn test: - bb0(v0:BasicObject): - v3:BasicObject = Send v0, 0x1000, :each - Return v3 + bb0(v0:BasicObject, v1:BasicObject): + v4:BasicObject = Send v1, 0x1000, :each + Return v4 "#]]); } @@ -3296,8 +3307,7 @@ mod tests { // The 2 string literals have the same address because they're deduped. assert_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): v2:ArrayExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) v4:ArrayExact = ArrayDup v2 v5:ArrayExact[VALUE(0x1008)] = Const Value(VALUE(0x1008)) @@ -3306,7 +3316,7 @@ mod tests { v9:StringExact = StringCopy v8 v10:StringExact[VALUE(0x1010)] = Const Value(VALUE(0x1010)) v11:StringExact = StringCopy v10 - v13:BasicObject = SendWithoutBlock v1, :unknown_method, v4, v7, v9, v11 + v13:BasicObject = SendWithoutBlock v0, :unknown_method, v4, v7, v9, v11 Return v13 "#]]); } @@ -3318,9 +3328,8 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf - v4:ArrayExact = ToArray v0 + bb0(v0:BasicObject, v1:BasicObject): + v4:ArrayExact = ToArray v1 SideExit "#]]); } @@ -3332,8 +3341,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): SideExit "#]]); } @@ -3345,8 +3353,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): v3:Fixnum[1] = Const Value(1) SideExit "#]]); @@ -3359,8 +3366,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): SideExit "#]]); } @@ -3374,8 +3380,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): SideExit "#]]); } @@ -3387,8 +3392,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): SideExit "#]]); } @@ -3400,8 +3404,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): SideExit "#]]); } @@ -3415,8 +3418,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): SideExit "#]]); } @@ -3428,9 +3430,8 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:ArrayExact): - v2:BasicObject = PutSelf - v4:ArrayExact = ToNewArray v0 + bb0(v0:BasicObject, v1:ArrayExact): + v4:ArrayExact = ToNewArray v1 v5:Fixnum[1] = Const Value(1) ArrayPush v4, v5 SideExit @@ -3444,8 +3445,7 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:BasicObject = PutSelf + bb0(v0:BasicObject, v1:BasicObject): SideExit "#]]); } @@ -3458,15 +3458,15 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_new, expect![[r#" fn test: - bb0(): - v1:BasicObject = GetConstantPath 0x1000 - v2:NilClassExact = Const Value(nil) - Jump bb1(v2, v1) - bb1(v4:NilClassExact, v5:BasicObject): - v8:BasicObject = SendWithoutBlock v5, :new - Jump bb2(v8, v4) - bb2(v10:BasicObject, v11:NilClassExact): - Return v10 + bb0(v0:BasicObject): + v2:BasicObject = GetConstantPath 0x1000 + v3:NilClassExact = Const Value(nil) + Jump bb1(v0, v3, v2) + bb1(v5:BasicObject, v6:NilClassExact, v7:BasicObject): + v10:BasicObject = SendWithoutBlock v7, :new + Jump bb2(v5, v10, v6) + bb2(v12:BasicObject, v13:BasicObject, v14:NilClassExact): + Return v13 "#]]); } @@ -3478,10 +3478,10 @@ mod tests { // TODO(max): Rewrite to nil assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(ARRAY_REDEFINED_OP_FLAG, BOP_MAX) - v3:BasicObject = ArrayMax - Return v3 + v4:BasicObject = ArrayMax + Return v4 "#]]); } @@ -3492,10 +3492,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(ARRAY_REDEFINED_OP_FLAG, BOP_MAX) - v5:BasicObject = ArrayMax v0, v1 - Return v5 + v6:BasicObject = ArrayMax v1, v2 + Return v6 "#]]); } @@ -3511,10 +3511,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v2:NilClassExact = Const Value(nil) + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): v3:NilClassExact = Const Value(nil) - v6:BasicObject = SendWithoutBlock v0, :+, v1 + v4:NilClassExact = Const Value(nil) + v7:BasicObject = SendWithoutBlock v1, :+, v2 SideExit "#]]); } @@ -3531,10 +3531,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v2:NilClassExact = Const Value(nil) + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): v3:NilClassExact = Const Value(nil) - v6:BasicObject = SendWithoutBlock v0, :+, v1 + v4:NilClassExact = Const Value(nil) + v7:BasicObject = SendWithoutBlock v1, :+, v2 SideExit "#]]); } @@ -3551,12 +3551,12 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v2:NilClassExact = Const Value(nil) + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): v3:NilClassExact = Const Value(nil) - v6:BasicObject = SendWithoutBlock v0, :+, v1 - v7:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v8:StringExact = StringCopy v7 + v4:NilClassExact = Const Value(nil) + v7:BasicObject = SendWithoutBlock v1, :+, v2 + v8:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v9:StringExact = StringCopy v8 SideExit "#]]); } @@ -3575,10 +3575,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_newarray_send, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v2:NilClassExact = Const Value(nil) + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): v3:NilClassExact = Const Value(nil) - v6:BasicObject = SendWithoutBlock v0, :+, v1 + v4:NilClassExact = Const Value(nil) + v7:BasicObject = SendWithoutBlock v1, :+, v2 SideExit "#]]); } @@ -3590,10 +3590,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_length, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:ArrayExact = NewArray v0, v1 - v6:BasicObject = SendWithoutBlock v4, :length - Return v6 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:ArrayExact = NewArray v1, v2 + v7:BasicObject = SendWithoutBlock v5, :length + Return v7 "#]]); } @@ -3604,10 +3604,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_size, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:ArrayExact = NewArray v0, v1 - v6:BasicObject = SendWithoutBlock v4, :size - Return v6 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:ArrayExact = NewArray v1, v2 + v7:BasicObject = SendWithoutBlock v5, :size + Return v7 "#]]); } @@ -3619,9 +3619,8 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_getinstancevariable, expect![[r#" fn test: - bb0(): - v2:BasicObject = PutSelf - v3:BasicObject = GetIvar v2, :@foo + bb0(v0:BasicObject): + v3:BasicObject = GetIvar v0, :@foo Return v3 "#]]); } @@ -3634,11 +3633,10 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_setinstancevariable, expect![[r#" fn test: - bb0(): - v1:Fixnum[1] = Const Value(1) - v3:BasicObject = PutSelf - SetIvar v3, :@foo, v1 - Return v1 + bb0(v0:BasicObject): + v2:Fixnum[1] = Const Value(1) + SetIvar v0, :@foo, v2 + Return v2 "#]]); } @@ -3649,9 +3647,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_splatarray, expect![[r#" fn test: - bb0(v0:BasicObject): - v3:ArrayExact = ToNewArray v0 - Return v3 + bb0(v0:BasicObject, v1:BasicObject): + v4:ArrayExact = ToNewArray v1 + Return v4 "#]]); } @@ -3662,12 +3660,12 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_concattoarray, expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) - v4:ArrayExact = NewArray v2 - v6:ArrayExact = ToArray v0 - ArrayExtend v4, v6 - Return v4 + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) + v5:ArrayExact = NewArray v3 + v7:ArrayExact = ToArray v1 + ArrayExtend v5, v7 + Return v5 "#]]); } @@ -3678,11 +3676,11 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_pushtoarray, expect![[r#" fn test: - bb0(v0:BasicObject): - v3:ArrayExact = ToNewArray v0 - v4:Fixnum[1] = Const Value(1) - ArrayPush v3, v4 - Return v3 + bb0(v0:BasicObject, v1:BasicObject): + v4:ArrayExact = ToNewArray v1 + v5:Fixnum[1] = Const Value(1) + ArrayPush v4, v5 + Return v4 "#]]); } @@ -3693,15 +3691,15 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_pushtoarray, expect![[r#" fn test: - bb0(v0:BasicObject): - v3:ArrayExact = ToNewArray v0 - v4:Fixnum[1] = Const Value(1) - v5:Fixnum[2] = Const Value(2) - v6:Fixnum[3] = Const Value(3) - ArrayPush v3, v4 - ArrayPush v3, v5 - ArrayPush v3, v6 - Return v3 + bb0(v0:BasicObject, v1:BasicObject): + v4:ArrayExact = ToNewArray v1 + v5:Fixnum[1] = Const Value(1) + v6:Fixnum[2] = Const Value(2) + v7:Fixnum[3] = Const Value(3) + ArrayPush v4, v5 + ArrayPush v4, v6 + ArrayPush v4, v7 + Return v4 "#]]); } @@ -3712,11 +3710,11 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_aset, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v3:NilClassExact = Const Value(nil) - v4:Fixnum[1] = Const Value(1) - v6:BasicObject = SendWithoutBlock v0, :[]=, v1, v4 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v4:NilClassExact = Const Value(nil) + v5:Fixnum[1] = Const Value(1) + v7:BasicObject = SendWithoutBlock v1, :[]=, v2, v5 + Return v5 "#]]); } @@ -3727,9 +3725,9 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_opt_aref, expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:BasicObject = SendWithoutBlock v0, :[], v1 - Return v4 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:BasicObject = SendWithoutBlock v1, :[], v2 + Return v5 "#]]); } @@ -3740,10 +3738,10 @@ mod tests { "); assert_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v4:BasicObject = SendWithoutBlock v0, :[], v2 - Return v4 + bb0(v0:BasicObject, v1:BasicObject): + v3:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v5:BasicObject = SendWithoutBlock v1, :[], v3 + Return v5 "#]]); } @@ -3754,13 +3752,13 @@ mod tests { "); assert_method_hir_with_opcode("test", YARVINSN_branchnil, expect![[r#" fn test: - bb0(v0:BasicObject): - v2:CBool = IsNil v0 - IfTrue v2, bb1(v0, v0) - v5:BasicObject = SendWithoutBlock v0, :itself - Jump bb1(v0, v5) - bb1(v7:BasicObject, v8:BasicObject): - Return v8 + bb0(v0:BasicObject, v1:BasicObject): + v3:CBool = IsNil v1 + IfTrue v3, bb1(v0, v1, v1) + v6:BasicObject = SendWithoutBlock v1, :itself + Jump bb1(v0, v1, v6) + bb1(v8:BasicObject, v9:BasicObject, v10:BasicObject): + Return v10 "#]]); } } @@ -3794,9 +3792,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v5:Fixnum[3] = Const Value(3) - Return v5 + bb0(v0:BasicObject): + v6:Fixnum[3] = Const Value(3) + Return v6 "#]]); } @@ -3814,12 +3812,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v2:FalseClassExact = Const Value(false) - Jump bb1(v2) - bb1(v7:FalseClassExact): - v9:Fixnum[4] = Const Value(4) - Return v9 + bb0(v0:BasicObject): + v3:FalseClassExact = Const Value(false) + Jump bb1(v0, v3) + bb1(v8:BasicObject, v9:FalseClassExact): + v11:Fixnum[4] = Const Value(4) + Return v11 "#]]); } @@ -3832,11 +3830,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v14:Fixnum[6] = Const Value(6) - Return v14 + v15:Fixnum[6] = Const Value(6) + Return v15 "#]]); } @@ -3849,11 +3847,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MINUS) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MINUS) - v14:Fixnum[1] = Const Value(1) - Return v14 + v15:Fixnum[1] = Const Value(1) + Return v15 "#]]); } @@ -3866,10 +3864,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MULT) - v8:Fixnum[42] = Const Value(42) - Return v8 + v9:Fixnum[42] = Const Value(42) + Return v9 "#]]); } @@ -3883,17 +3881,17 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[0] = Const Value(0) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[0] = Const Value(0) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MULT) - v12:Fixnum = GuardType v0, Fixnum - v19:Fixnum[0] = Const Value(0) - v5:Fixnum[0] = Const Value(0) + v13:Fixnum = GuardType v1, Fixnum + v20:Fixnum[0] = Const Value(0) + v6:Fixnum[0] = Const Value(0) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MULT) - v15:Fixnum = GuardType v0, Fixnum + v16:Fixnum = GuardType v1, Fixnum PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v21:Fixnum[0] = Const Value(0) - Return v21 + v22:Fixnum[0] = Const Value(0) + Return v22 "#]]); } @@ -3910,10 +3908,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LT) - v7:Fixnum[3] = Const Value(3) - Return v7 + v8:Fixnum[3] = Const Value(3) + Return v8 "#]]); } @@ -3930,11 +3928,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LE) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LE) - v13:Fixnum[3] = Const Value(3) - Return v13 + v14:Fixnum[3] = Const Value(3) + Return v14 "#]]); } @@ -3951,10 +3949,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_GT) - v7:Fixnum[3] = Const Value(3) - Return v7 + v8:Fixnum[3] = Const Value(3) + Return v8 "#]]); } @@ -3971,11 +3969,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_GE) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_GE) - v13:Fixnum[3] = Const Value(3) - Return v13 + v14:Fixnum[3] = Const Value(3) + Return v14 "#]]); } @@ -3992,12 +3990,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) - Jump bb1() - bb1(): - v10:Fixnum[4] = Const Value(4) - Return v10 + Jump bb1(v0) + bb1(v10:BasicObject): + v12:Fixnum[4] = Const Value(4) + Return v12 "#]]); } @@ -4014,10 +4012,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) - v7:Fixnum[3] = Const Value(3) - Return v7 + v8:Fixnum[3] = Const Value(3) + Return v8 "#]]); } @@ -4034,11 +4032,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_NEQ) - v7:Fixnum[3] = Const Value(3) - Return v7 + v8:Fixnum[3] = Const Value(3) + Return v8 "#]]); } @@ -4055,13 +4053,13 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_NEQ) - Jump bb1() - bb1(): - v10:Fixnum[4] = Const Value(4) - Return v10 + Jump bb1(v0) + bb1(v10:BasicObject): + v12:Fixnum[4] = Const Value(4) + Return v12 "#]]); } @@ -4075,12 +4073,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v7:Fixnum = GuardType v0, Fixnum - v8:Fixnum = FixnumAdd v7, v2 - Return v8 + v8:Fixnum = GuardType v1, Fixnum + v9:Fixnum = FixnumAdd v8, v3 + Return v9 "#]]); } @@ -4097,36 +4095,36 @@ mod opt_tests { assert_optimized_method_hir("rest", expect![[r#" fn rest: - bb0(v0:ArrayExact): - Return v0 + bb0(v0:BasicObject, v1:ArrayExact): + Return v1 "#]]); // extra hidden param for the set of specified keywords assert_optimized_method_hir("kw", expect![[r#" fn kw: - bb0(v0:BasicObject, v1:BasicObject): - Return v0 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + Return v1 "#]]); assert_optimized_method_hir("kw_rest", expect![[r#" fn kw_rest: - bb0(v0:BasicObject): - Return v0 + bb0(v0:BasicObject, v1:BasicObject): + Return v1 "#]]); assert_optimized_method_hir("block", expect![[r#" fn block: - bb0(v0:BasicObject): - v2:NilClassExact = Const Value(nil) - Return v2 + bb0(v0:BasicObject, v1:BasicObject): + v3:NilClassExact = Const Value(nil) + Return v3 "#]]); assert_optimized_method_hir("post", expect![[r#" fn post: - bb0(v0:ArrayExact, v1:BasicObject): - Return v1 + bb0(v0:BasicObject, v1:ArrayExact, v2:BasicObject): + Return v2 "#]]); assert_optimized_method_hir("forwardable", expect![[r#" fn forwardable: - bb0(v0:BasicObject): - v2:NilClassExact = Const Value(nil) - Return v2 + bb0(v0:BasicObject, v1:BasicObject): + v3:NilClassExact = Const Value(nil) + Return v3 "#]]); } @@ -4142,10 +4140,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): PatchPoint MethodRedefined(Object@0x1000, foo@0x1008) - v6:BasicObject[VALUE(0x1010)] = GuardBitEquals v1, VALUE(0x1010) + v6:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) v7:BasicObject = SendWithoutBlockDirect v6, :foo (0x1018) Return v7 "#]]); @@ -4164,9 +4161,8 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf - v3:BasicObject = SendWithoutBlock v1, :foo + bb0(v0:BasicObject): + v3:BasicObject = SendWithoutBlock v0, :foo Return v3 "#]]); } @@ -4184,10 +4180,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): PatchPoint MethodRedefined(Object@0x1000, foo@0x1008) - v6:BasicObject[VALUE(0x1010)] = GuardBitEquals v1, VALUE(0x1010) + v6:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) v7:BasicObject = SendWithoutBlockDirect v6, :foo (0x1018) Return v7 "#]]); @@ -4203,11 +4198,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): v2:Fixnum[3] = Const Value(3) PatchPoint MethodRedefined(Object@0x1000, Integer@0x1008) - v7:BasicObject[VALUE(0x1010)] = GuardBitEquals v1, VALUE(0x1010) + v7:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) v8:BasicObject = SendWithoutBlockDirect v7, :Integer (0x1018), v2 Return v8 "#]]); @@ -4225,12 +4219,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): v2:Fixnum[1] = Const Value(1) v3:Fixnum[2] = Const Value(2) PatchPoint MethodRedefined(Object@0x1000, foo@0x1008) - v8:BasicObject[VALUE(0x1010)] = GuardBitEquals v1, VALUE(0x1010) + v8:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) v9:BasicObject = SendWithoutBlockDirect v8, :foo (0x1018), v2, v3 Return v9 "#]]); @@ -4251,16 +4244,14 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = PutSelf + bb0(v0:BasicObject): PatchPoint MethodRedefined(Object@0x1000, foo@0x1008) - v9:BasicObject[VALUE(0x1010)] = GuardBitEquals v1, VALUE(0x1010) - v10:BasicObject = SendWithoutBlockDirect v9, :foo (0x1018) - v4:BasicObject = PutSelf + v8:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) + v9:BasicObject = SendWithoutBlockDirect v8, :foo (0x1018) PatchPoint MethodRedefined(Object@0x1000, bar@0x1020) - v12:BasicObject[VALUE(0x1010)] = GuardBitEquals v4, VALUE(0x1010) - v13:BasicObject = SendWithoutBlockDirect v12, :bar (0x1018) - Return v13 + v11:BasicObject[VALUE(0x1010)] = GuardBitEquals v0, VALUE(0x1010) + v12:BasicObject = SendWithoutBlockDirect v11, :bar (0x1018) + Return v12 "#]]); } @@ -4272,12 +4263,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v7:Fixnum = GuardType v0, Fixnum v8:Fixnum = GuardType v1, Fixnum - v9:Fixnum = FixnumAdd v7, v8 - Return v9 + v9:Fixnum = GuardType v2, Fixnum + v10:Fixnum = FixnumAdd v8, v9 + Return v10 "#]]); } @@ -4289,12 +4280,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v7:Fixnum = GuardType v0, Fixnum - v8:Fixnum = FixnumAdd v7, v2 - Return v8 + v8:Fixnum = GuardType v1, Fixnum + v9:Fixnum = FixnumAdd v8, v3 + Return v9 "#]]); } @@ -4306,12 +4297,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v7:Fixnum = GuardType v0, Fixnum - v8:Fixnum = FixnumAdd v2, v7 - Return v8 + v8:Fixnum = GuardType v1, Fixnum + v9:Fixnum = FixnumAdd v3, v8 + Return v9 "#]]); } @@ -4323,12 +4314,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LT) - v7:Fixnum = GuardType v0, Fixnum v8:Fixnum = GuardType v1, Fixnum - v9:BoolExact = FixnumLt v7, v8 - Return v9 + v9:Fixnum = GuardType v2, Fixnum + v10:BoolExact = FixnumLt v8, v9 + Return v10 "#]]); } @@ -4340,12 +4331,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LT) - v7:Fixnum = GuardType v0, Fixnum - v8:BoolExact = FixnumLt v7, v2 - Return v8 + v8:Fixnum = GuardType v1, Fixnum + v9:BoolExact = FixnumLt v8, v3 + Return v9 "#]]); } @@ -4357,12 +4348,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LT) - v7:Fixnum = GuardType v0, Fixnum - v8:BoolExact = FixnumLt v2, v7 - Return v8 + v8:Fixnum = GuardType v1, Fixnum + v9:BoolExact = FixnumLt v3, v8 + Return v9 "#]]); } @@ -4377,9 +4368,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v4:Fixnum[5] = Const Value(5) - Return v4 + bb0(v0:BasicObject): + v5:Fixnum[5] = Const Value(5) + Return v5 "#]]); } @@ -4394,9 +4385,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v3:Fixnum[5] = Const Value(5) - Return v3 + bb0(v0:BasicObject): + v4:Fixnum[5] = Const Value(5) + Return v4 "#]]); } @@ -4411,9 +4402,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v5:Fixnum[5] = Const Value(5) - Return v5 + bb0(v0:BasicObject, v1:BasicObject): + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4427,9 +4418,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v4:Fixnum[5] = Const Value(5) - Return v4 + bb0(v0:BasicObject): + v5:Fixnum[5] = Const Value(5) + Return v5 "#]]); } @@ -4443,9 +4434,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v8:Fixnum[5] = Const Value(5) - Return v8 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v9:Fixnum[5] = Const Value(5) + Return v9 "#]]); } @@ -4460,9 +4451,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v5:Fixnum[5] = Const Value(5) - Return v5 + bb0(v0:BasicObject): + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4476,9 +4467,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v5:Fixnum[5] = Const Value(5) - Return v5 + bb0(v0:BasicObject): + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4493,7 +4484,7 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): v3:Fixnum[5] = Const Value(5) Return v3 "#]]); @@ -4510,9 +4501,9 @@ mod opt_tests { "#); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v4:Fixnum[5] = Const Value(5) - Return v4 + bb0(v0:BasicObject): + v5:Fixnum[5] = Const Value(5) + Return v5 "#]]); } @@ -4527,12 +4518,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_PLUS) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4547,12 +4538,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MINUS) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4567,12 +4558,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MULT) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4587,13 +4578,13 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_DIV) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v10:Fixnum = FixnumDiv v8, v9 - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v11:Fixnum = FixnumDiv v9, v10 + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4608,13 +4599,13 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_MOD) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v10:Fixnum = FixnumMod v8, v9 - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v11:Fixnum = FixnumMod v9, v10 + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4629,12 +4620,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LT) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4649,12 +4640,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_LE) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4669,12 +4660,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_GT) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4689,12 +4680,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_GE) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4709,12 +4700,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) - v8:Fixnum = GuardType v0, Fixnum v9:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v10:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4729,13 +4720,13 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_EQ) PatchPoint BOPRedefined(INTEGER_REDEFINED_OP_FLAG, BOP_NEQ) - v9:Fixnum = GuardType v0, Fixnum v10:Fixnum = GuardType v1, Fixnum - v5:Fixnum[5] = Const Value(5) - Return v5 + v11:Fixnum = GuardType v2, Fixnum + v6:Fixnum[5] = Const Value(5) + Return v6 "#]]); } @@ -4749,10 +4740,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = GetConstantPath 0x1000 - v2:Fixnum[5] = Const Value(5) - Return v2 + bb0(v0:BasicObject): + v2:BasicObject = GetConstantPath 0x1000 + v3:Fixnum[5] = Const Value(5) + Return v3 "#]]); } @@ -4765,11 +4756,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): + bb0(v0:BasicObject, v1:BasicObject): PatchPoint MethodRedefined(Integer@0x1000, itself@0x1008) - v6:Fixnum = GuardType v0, Fixnum - v7:BasicObject = CCall itself@0x1010, v6 - Return v7 + v7:Fixnum = GuardType v1, Fixnum + v8:BasicObject = CCall itself@0x1010, v7 + Return v8 "#]]); } @@ -4780,11 +4771,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v2:ArrayExact = NewArray + bb0(v0:BasicObject): + v3:ArrayExact = NewArray PatchPoint MethodRedefined(Array@0x1000, itself@0x1008) - v7:BasicObject = CCall itself@0x1010, v2 - Return v7 + v8:BasicObject = CCall itself@0x1010, v3 + Return v8 "#]]); } @@ -4798,10 +4789,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint MethodRedefined(Array@0x1000, itself@0x1008) - v6:Fixnum[1] = Const Value(1) - Return v6 + v7:Fixnum[1] = Const Value(1) + Return v7 "#]]); } @@ -4817,12 +4808,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint SingleRactorMode PatchPoint StableConstantNames(0x1000, M) PatchPoint MethodRedefined(Module@0x1008, name@0x1010) - v5:Fixnum[1] = Const Value(1) - Return v5 + v6:Fixnum[1] = Const Value(1) + Return v6 "#]]); } @@ -4836,10 +4827,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint MethodRedefined(Array@0x1000, length@0x1008) - v6:Fixnum[5] = Const Value(5) - Return v6 + v7:Fixnum[5] = Const Value(5) + Return v7 "#]]); } @@ -4853,10 +4844,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint MethodRedefined(Array@0x1000, size@0x1008) - v6:Fixnum[5] = Const Value(5) - Return v6 + v7:Fixnum[5] = Const Value(5) + Return v7 "#]]); } @@ -4870,11 +4861,11 @@ mod opt_tests { // Not specialized assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:Fixnum[1] = Const Value(1) - v2:Fixnum[0] = Const Value(0) - v4:BasicObject = SendWithoutBlock v1, :itself, v2 - Return v4 + bb0(v0:BasicObject): + v2:Fixnum[1] = Const Value(1) + v3:Fixnum[0] = Const Value(0) + v5:BasicObject = SendWithoutBlock v2, :itself, v3 + Return v5 "#]]); } @@ -4885,11 +4876,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v2:Fixnum[1] = Const Value(1) + bb0(v0:BasicObject, v1:BasicObject): + v3:Fixnum[1] = Const Value(1) PatchPoint MethodRedefined(Integer@0x1000, zero?@0x1008) - v7:BasicObject = SendWithoutBlockDirect v2, :zero? (0x1010) - Return v7 + v8:BasicObject = SendWithoutBlockDirect v3, :zero? (0x1010) + Return v8 "#]]); } @@ -4903,13 +4894,13 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject): - v1:NilClassExact = Const Value(nil) - v3:ArrayExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v5:ArrayExact = ArrayDup v3 + bb0(v0:BasicObject, v1:BasicObject): + v2:NilClassExact = Const Value(nil) + v4:ArrayExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v6:ArrayExact = ArrayDup v4 PatchPoint MethodRedefined(Array@0x1008, first@0x1010) - v10:BasicObject = SendWithoutBlockDirect v5, :first (0x1018) - Return v10 + v11:BasicObject = SendWithoutBlockDirect v6, :first (0x1018) + Return v11 "#]]); } @@ -4922,12 +4913,12 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) - v2:StringExact = StringCopy v1 + bb0(v0:BasicObject): + v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000)) + v3:StringExact = StringCopy v2 PatchPoint MethodRedefined(String@0x1008, bytesize@0x1010) - v7:Fixnum = CCall bytesize@0x1018, v2 - Return v7 + v8:Fixnum = CCall bytesize@0x1018, v3 + Return v8 "#]]); } @@ -4938,9 +4929,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = GetConstantPath 0x1000 - Return v1 + bb0(v0:BasicObject): + v2:BasicObject = GetConstantPath 0x1000 + Return v2 "#]]); } @@ -4953,9 +4944,9 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:BasicObject = GetConstantPath 0x1000 - Return v1 + bb0(v0:BasicObject): + v2:BasicObject = GetConstantPath 0x1000 + Return v2 "#]]); } @@ -4967,11 +4958,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint SingleRactorMode PatchPoint StableConstantNames(0x1000, Kernel) - v5:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) - Return v5 + v6:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) + Return v6 "#]]); } @@ -4989,11 +4980,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint SingleRactorMode PatchPoint StableConstantNames(0x1000, Foo::Bar::C) - v5:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) - Return v5 + v6:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) + Return v6 "#]]); } @@ -5006,17 +4997,17 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint SingleRactorMode PatchPoint StableConstantNames(0x1000, C) - v16:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) - v2:NilClassExact = Const Value(nil) - Jump bb1(v2, v16) - bb1(v4:NilClassExact, v5:BasicObject[VALUE(0x1008)]): - v8:BasicObject = SendWithoutBlock v5, :new - Jump bb2(v8, v4) - bb2(v10:BasicObject, v11:NilClassExact): - Return v10 + v19:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) + v3:NilClassExact = Const Value(nil) + Jump bb1(v0, v3, v19) + bb1(v5:BasicObject, v6:NilClassExact, v7:BasicObject[VALUE(0x1008)]): + v10:BasicObject = SendWithoutBlock v7, :new + Jump bb2(v5, v10, v6) + bb2(v12:BasicObject, v13:BasicObject, v14:NilClassExact): + Return v13 "#]]); } @@ -5033,18 +5024,18 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): + bb0(v0:BasicObject): PatchPoint SingleRactorMode PatchPoint StableConstantNames(0x1000, C) - v18:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) - v2:NilClassExact = Const Value(nil) - v3:Fixnum[1] = Const Value(1) - Jump bb1(v2, v18, v3) - bb1(v5:NilClassExact, v6:BasicObject[VALUE(0x1008)], v7:Fixnum[1]): - v10:BasicObject = SendWithoutBlock v6, :new, v7 - Jump bb2(v10, v5) - bb2(v12:BasicObject, v13:NilClassExact): - Return v12 + v21:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008)) + v3:NilClassExact = Const Value(nil) + v4:Fixnum[1] = Const Value(1) + Jump bb1(v0, v3, v21, v4) + bb1(v6:BasicObject, v7:NilClassExact, v8:BasicObject[VALUE(0x1008)], v9:Fixnum[1]): + v12:BasicObject = SendWithoutBlock v8, :new, v9 + Jump bb2(v6, v12, v7) + bb2(v14:BasicObject, v15:BasicObject, v16:NilClassExact): + Return v15 "#]]); } @@ -5055,11 +5046,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:ArrayExact = NewArray v0, v1 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:ArrayExact = NewArray v1, v2 PatchPoint MethodRedefined(Array@0x1000, length@0x1008) - v9:Fixnum = CCall length@0x1010, v4 - Return v9 + v10:Fixnum = CCall length@0x1010, v5 + Return v10 "#]]); } @@ -5070,11 +5061,11 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(v0:BasicObject, v1:BasicObject): - v4:ArrayExact = NewArray v0, v1 + bb0(v0:BasicObject, v1:BasicObject, v2:BasicObject): + v5:ArrayExact = NewArray v1, v2 PatchPoint MethodRedefined(Array@0x1000, size@0x1008) - v9:Fixnum = CCall size@0x1010, v4 - Return v9 + v10:Fixnum = CCall size@0x1010, v5 + Return v10 "#]]); } @@ -5085,9 +5076,8 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v2:BasicObject = PutSelf - v3:BasicObject = GetIvar v2, :@foo + bb0(v0:BasicObject): + v3:BasicObject = GetIvar v0, :@foo Return v3 "#]]); } @@ -5099,11 +5089,10 @@ mod opt_tests { "); assert_optimized_method_hir("test", expect![[r#" fn test: - bb0(): - v1:Fixnum[1] = Const Value(1) - v3:BasicObject = PutSelf - SetIvar v3, :@foo, v1 - Return v1 + bb0(v0:BasicObject): + v2:Fixnum[1] = Const Value(1) + SetIvar v0, :@foo, v2 + Return v2 "#]]); } }