WIP

Author: st0012

test/ruby/test_zjit.rb

@@ -489,6 +489,21 @@ def test = [1,2,3]
     }
   end
 
+  def test_array_splat
+    assert_compiles '"foo"', %q{
+      def foo(b) = b
+      def test(a) = foo(*a)
+      test("foo")
+    }, insns: [:splatarray]
+  end
+
+  def test_array_concat_implicit
+    assert_compiles '[1, 2, 3]', %q{
+      def test(a) = [1, *a]
+      test([2, 3])
+    }, insns: [:concattoarray]
+  end
+
   def test_new_range_inclusive
     assert_compiles '1..5', %q{
       def test(a, b) = a..b

zjit/bindgen/src/main.rs

@@ -149,8 +149,11 @@ fn main() {
         .allowlist_function("rb_ary_dup")
         .allowlist_function("rb_ary_push")
         .allowlist_function("rb_ary_unshift_m")
+        .allowlist_function("rb_ary_concat")
+        .allowlist_function("rb_check_to_array")
 
         // From internal/array.h
+        .allowlist_function("rb_to_array_type")
         .allowlist_function("rb_ec_ary_new_from_values")
         .allowlist_function("rb_ary_tmp_new_from_values")
 

zjit/src/codegen.rs

@@ -367,7 +367,8 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::AnyToString { val, str, state } => gen_anytostring(asm, opnd!(val), opnd!(str), &function.frame_state(*state))?,
         Insn::Defined { op_type, obj, pushval, v } => gen_defined(jit, asm, *op_type, *obj, *pushval, opnd!(v))?,
         &Insn::IncrCounter(counter) => return Some(gen_incr_counter(asm, counter)),
-        Insn::ArrayExtend { .. }
+        Insn::ToArray { val, state } => gen_to_array(asm, opnd!(val), &function.frame_state(*state))?,
+        Insn::ArrayExtend { left, right, state } => return gen_array_extend(asm, opnd!(left), opnd!(right), &function.frame_state(*state)),
         | Insn::ArrayMax { .. }
         | Insn::ArrayPush { .. }
         | Insn::DefinedIvar { .. }
@@ -379,7 +380,6 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         | Insn::Send { .. }
         | Insn::StringIntern { .. }
         | Insn::Throw { .. }
-        | Insn::ToArray { .. }
         | Insn::ToNewArray { .. }
         | Insn::Const { .. }
         => {
@@ -1042,6 +1042,42 @@ fn gen_anytostring(asm: &mut Assembler, val: lir::Opnd, str: lir::Opnd, state: &
     Some(asm_ccall!(asm, rb_obj_as_string_result, str, val))
 }
 
+fn gen_to_array(asm: &mut Assembler, val: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
+    // Save PC
+    gen_save_pc(asm, state);
+
+    let klass = asm.ccall(rb_yarv_class_of as *const u8, vec![val]);
+    asm.cmp(klass, Opnd::Value(unsafe { rb_cArray }));
+
+    // Store whether val is an array (1 if array, 0 if not)
+    let is_array = asm.csel_e(Opnd::Imm(1), Opnd::Imm(0));
+    // Try to convert value to array using to_a
+    let converted = asm_ccall!(asm, rb_check_to_array, val);
+
+    // Create array with single element (for when conversion fails)
+    let wrapped = gen_new_array(asm, vec![val], state);
+
+    // Check if conversion succeeded (returned non-nil)
+    asm.cmp(converted, Qnil.into());
+
+    // If conversion failed (nil), use wrapped; otherwise use converted
+    let converted_or_wrapped = asm.csel_e(wrapped, converted);
+
+    // If val was already array, use it; otherwise use converted_or_wrapped
+    asm.cmp(is_array, Opnd::Imm(1));
+    let result = asm.csel_e(val, converted_or_wrapped);
+
+    Some(result)
+}
+
+fn gen_array_extend(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> Option<()> {
+    // Save PC
+    gen_save_pc(asm, state);
+
+    asm_ccall!(asm, rb_ary_concat, left, right);
+    Some(())
+}
+
 /// Evaluate if a value is truthy
 /// Produces a CBool type (0 or 1)
 /// In Ruby, only nil and false are falsy