summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorTakashi Kokubun <takashikkbn@gmail.com>2025-06-05 14:48:04 -0700
committerGitHub <noreply@github.com>2025-06-05 14:48:04 -0700
commit1a991131a04feb3527f7e4993491b587d2e57179 (patch)
tree1b69cc884013576f53c5b2d7f016afc6e176445c
parent4e39580992064a4e91e9b8626a1a220f262a7011 (diff)
ZJIT: Pass self through basic block params (#13529)
* ZJIT: Pass self through basic block params Co-authored-by: Max Bernstein <tekknolagi@gmail.com> * 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 <tekknolagi@gmail.com> * Fix test_unknown --------- Co-authored-by: Max Bernstein <tekknolagi@gmail.com>
Notes
Notes: Merged-By: k0kubun <takashikkbn@gmail.com>
Diffstat
-rw-r--r--test/ruby/test_zjit.rb11
-rw-r--r--zjit/src/backend/arm64/mod.rs4
-rw-r--r--zjit/src/backend/lir.rs4
-rw-r--r--zjit/src/codegen.rs29
-rw-r--r--zjit/src/hir.rs1141
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<Opnd> = (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<InsnId>,
) -> Option<lir::Opnd> {
- // 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<Opnd> = 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<InsnId> {
- self.locals.iter().chain(self.stack.iter()).map(|op| *op).collect()
+ fn as_args(&self, self_param: InsnId) -> Vec<InsnId> {
+ // 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<Function, ParseError> {
let payload = get_or_create_iseq_payload(iseq);
@@ -1981,16 +1989,18 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
// 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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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<Function, ParseError> {
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
"#]]);
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-21 22:22:22 +0000