WIP

Author: st0012

zjit/src/codegen.rs

@@ -346,7 +346,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::Const { val: Const::Value(val) } => gen_const(*val),
         Insn::Const { .. } => panic!("Unexpected Const in gen_insn: {insn}"),
         Insn::NewArray { elements, state } => gen_new_array(asm, opnds!(elements), &function.frame_state(*state)),
-        Insn::NewHash { elements, state } => gen_new_hash(jit, asm, opnds!(elements), &function.frame_state(*state)),
+        Insn::NewHash { elements_ptr, elements_count, state } => gen_new_hash(jit, asm, opnd!(elements_ptr), *elements_count, &function.frame_state(*state)),
         Insn::NewRange { low, high, flag, state } => gen_new_range(jit, asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)),
         Insn::NewRangeFixnum { low, high, flag, state } => gen_new_range_fixnum(asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)),
         Insn::ArrayDup { val, state } => gen_array_dup(asm, opnd!(val), &function.frame_state(*state)),
@@ -1259,19 +1259,17 @@ fn gen_new_array(
 fn gen_new_hash(
     jit: &mut JITState,
     asm: &mut Assembler,
-    elements: Vec<Opnd>,
+    elements_ptr: Opnd,
+    elements_count: usize,
     state: &FrameState,
 ) -> lir::Opnd {
     gen_prepare_non_leaf_call(jit, asm, state);
 
-    let cap: c_long = elements.len().try_into().expect("Unable to fit length of elements into c_long");
+    let cap: c_long = elements_count.try_into().expect("Unable to fit length of elements into c_long");
     let new_hash = asm_ccall!(asm, rb_hash_new_with_size, lir::Opnd::Imm(cap));
 
-    if !elements.is_empty() {
-        let argv = gen_push_opnds(jit, asm, &elements);
-        asm_ccall!(asm, rb_hash_bulk_insert, elements.len().into(), argv, new_hash);
-
-        gen_pop_opnds(asm, &elements);
+    if elements_count > 0 {
+        asm_ccall!(asm, rb_hash_bulk_insert, elements_count.into(), elements_ptr, new_hash);
     }
 
     new_hash

zjit/src/hir.rs

@@ -549,7 +549,7 @@ pub enum Insn {
     ToNewArray { val: InsnId, state: InsnId },
     NewArray { elements: Vec<InsnId>, state: InsnId },
     /// NewHash contains a vec of (key, value) pairs
-    NewHash { elements: Vec<InsnId>, state: InsnId },
+    NewHash { elements_ptr: InsnId, elements_count: usize, state: InsnId },
     NewRange { low: InsnId, high: InsnId, flag: RangeType, state: InsnId },
     NewRangeFixnum { low: InsnId, high: InsnId, flag: RangeType, state: InsnId },
     ArrayDup { val: InsnId, state: InsnId },
@@ -755,7 +755,7 @@ impl Insn {
             Insn::NewArray { .. } => false,
             // NewHash's operands may be hashed and compared for equality, which could have
             // side-effects.
-            Insn::NewHash { elements, .. } => !elements.is_empty(),
+            Insn::NewHash { elements_count, .. } => *elements_count > 0,
             Insn::ArrayDup { .. } => false,
             Insn::HashDup { .. } => false,
             Insn::Test { .. } => false,
@@ -817,16 +817,8 @@ impl<'a> std::fmt::Display for InsnPrinter<'a> {
                 }
                 Ok(())
             }
-            Insn::NewHash { elements, .. } => {
-                write!(f, "NewHash")?;
-                let mut prefix = " ";
-                for chunk in elements.chunks(2) {
-                    if let [key, value] = chunk {
-                        write!(f, "{prefix}{key}: {value}")?;
-                        prefix = ", ";
-                    }
-                }
-                Ok(())
+            Insn::NewHash { elements_ptr, elements_count, .. } => {
+                write!(f, "NewHash {elements_ptr} ({elements_count})")
             }
             Insn::NewRange { low, high, flag, .. } => {
                 write!(f, "NewRange {low} {flag} {high}")
@@ -1462,7 +1454,7 @@ impl Function {
             &Defined { op_type, obj, pushval, v, state } => Defined { op_type, obj, pushval, v: find!(v), state: find!(state) },
             &DefinedIvar { self_val, pushval, id, state } => DefinedIvar { self_val: find!(self_val), pushval, id, state },
             &NewArray { ref elements, state } => NewArray { elements: find_vec!(elements), state: find!(state) },
-            &NewHash { ref elements, state } => NewHash { elements: find_vec!(elements), state: find!(state) },
+            &NewHash { elements_ptr, elements_count, state } => NewHash { elements_ptr: find!(elements_ptr), elements_count, state: find!(state) },
             &NewRange { low, high, flag, state } => NewRange { low: find!(low), high: find!(high), flag, state: find!(state) },
             &NewRangeFixnum { low, high, flag, state } => NewRangeFixnum { low: find!(low), high: find!(high), flag, state: find!(state) },
             &ArrayMax { ref elements, state } => ArrayMax { elements: find_vec!(elements), state: find!(state) },
@@ -2375,13 +2367,8 @@ impl Function {
                 worklist.extend(elements);
                 worklist.push_back(state);
             }
-            &Insn::NewHash { ref elements, state } => {
-                for chunk in elements.chunks(2) {
-                    if let &[key, value] = chunk {
-                        worklist.push_back(key);
-                        worklist.push_back(value);
-                    }
-                }
+            &Insn::NewHash { elements_ptr, state, .. } => {
+                worklist.push_back(elements_ptr);
                 worklist.push_back(state);
             }
             &Insn::NewRange { low, high, state, .. }
@@ -3451,7 +3438,8 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                         elements.push(key);
                         elements.push(value);
                     }
-                    state.stack_push(fun.push_insn(block, Insn::NewHash { elements, state: exit_id }));
+                    let elements_ptr = fun.push_insn(block, Insn::PushOpnds { opnds: elements });
+                    state.stack_push(fun.push_insn(block, Insn::NewHash { elements_ptr, elements_count: count, state: exit_id }));
                 }
                 YARVINSN_duphash => {
                     let val = fun.push_insn(block, Insn::Const { val: Const::Value(get_arg(pc, 0)) });