WIP

Author: st0012

zjit/src/codegen.rs

@@ -397,8 +397,8 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         &Insn::GuardBlockParamProxy { level, state } => no_output!(gen_guard_block_param_proxy(jit, asm, level, &function.frame_state(state))),
         Insn::PatchPoint { invariant, state } => no_output!(gen_patch_point(jit, asm, invariant, &function.frame_state(*state))),
         Insn::CCall { cfun, args, name: _, return_type: _, elidable: _ } => gen_ccall(asm, *cfun, opnds!(args)),
-        Insn::CCallVariadic { cfun, recv, args, name: _, cme, state } => {
-            gen_ccall_variadic(jit, asm, *cfun, opnd!(recv), opnds!(args), *cme, &function.frame_state(*state))
+        Insn::CCallVariadic { cfun, recv, args_ptr, args_count, name: _, cme, state } => {
+            gen_ccall_variadic(jit, asm, *cfun, opnd!(recv), opnd!(args_ptr), *args_count, *cme, &function.frame_state(*state))
         }
         Insn::GetIvar { self_val, id, state: _ } => gen_getivar(asm, opnd!(self_val), *id),
         Insn::SetGlobal { id, val, state } => no_output!(gen_setglobal(jit, asm, *id, opnd!(val), &function.frame_state(*state))),
@@ -656,21 +656,22 @@ fn gen_ccall_variadic(
     asm: &mut Assembler,
     cfun: *const u8,
     recv: Opnd,
-    args: Vec<Opnd>,
+    args_ptr: Opnd,
+    args_count: usize,
     cme: *const rb_callable_method_entry_t,
     state: &FrameState,
 ) -> lir::Opnd {
     gen_prepare_non_leaf_call(jit, asm, state);
 
-    gen_push_frame(asm, args.len(), state, ControlFrame {
+    gen_push_frame(asm, args_count, state, ControlFrame {
         recv,
         iseq: None,
         cme,
         frame_type: VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL,
     });
 
     asm_comment!(asm, "switch to new SP register");
-    let sp_offset = (state.stack().len() - args.len() + VM_ENV_DATA_SIZE.as_usize()) * SIZEOF_VALUE;
+    let sp_offset = (state.stack().len() - args_count + VM_ENV_DATA_SIZE.as_usize()) * SIZEOF_VALUE;
     let new_sp = asm.add(SP, sp_offset.into());
     asm.mov(SP, new_sp);
 
@@ -679,9 +680,7 @@ fn gen_ccall_variadic(
     asm.mov(CFP, new_cfp);
     asm.store(Opnd::mem(64, EC, RUBY_OFFSET_EC_CFP), CFP);
 
-    let argv_ptr = gen_push_opnds(jit, asm, &args);
-    let result = asm.ccall(cfun, vec![args.len().into(), argv_ptr, recv]);
-    gen_pop_opnds(asm, &args);
+    let result = asm.ccall(cfun, vec![args_count.into(), args_ptr, recv]);
 
     asm_comment!(asm, "pop C frame");
     let new_cfp = asm.add(CFP, RUBY_SIZEOF_CONTROL_FRAME.into());

zjit/src/hir.rs

@@ -630,7 +630,8 @@ pub enum Insn {
     CCallVariadic {
         cfun: *const u8,
         recv: InsnId,
-        args: Vec<InsnId>,
+        args_ptr: InsnId,
+        args_count: usize,
         cme: *const rb_callable_method_entry_t,
         name: ID,
         state: InsnId,
@@ -954,12 +955,9 @@ impl<'a> std::fmt::Display for InsnPrinter<'a> {
                 }
                 Ok(())
             },
-            Insn::CCallVariadic { cfun,  recv, args, name, .. } => {
+            Insn::CCallVariadic { cfun,  recv, args_ptr, args_count, name, .. } => {
                 write!(f, "CCallVariadic {}@{:p}, {recv}", name.contents_lossy(), self.ptr_map.map_ptr(cfun))?;
-                for arg in args {
-                    write!(f, ", {arg}")?;
-                }
-                Ok(())
+                write!(f, ", {args_ptr} ({args_count})")
             },
             Insn::Snapshot { state } => write!(f, "Snapshot {}", state.print(self.ptr_map)),
             Insn::Defined { op_type, v, .. } => {
@@ -1458,8 +1456,8 @@ impl Function {
             &ObjectAlloc { val, state } => ObjectAlloc { val: find!(val), state },
             &ObjectAllocClass { class, state } => ObjectAllocClass { class, state: find!(state) },
             &CCall { cfun, ref args, name, return_type, elidable } => CCall { cfun, args: find_vec!(args), name, return_type, elidable },
-            &CCallVariadic { cfun, recv, ref args, cme, name, state } => CCallVariadic {
-                cfun, recv: find!(recv), args: find_vec!(args), cme, name, state
+            &CCallVariadic { cfun, recv, args_ptr, args_count, cme, name, state } => CCallVariadic {
+                cfun, recv: find!(recv), args_ptr: find!(args_ptr), args_count, cme, name, state
             },
             &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 },
@@ -2140,16 +2138,20 @@ impl Function {
                         });
 
                         let cfun = unsafe { get_mct_func(cfunc) }.cast();
+                        let args_count = args.len();
+                        let args_ptr = fun.push_insn(block, Insn::PushOpnds { opnds: args });
                         let ccall = fun.push_insn(block, Insn::CCallVariadic {
                             cfun,
                             recv,
-                            args,
+                            args_ptr,
+                            args_count,
                             cme: method,
                             name: method_id,
                             state,
                         });
 
                         fun.make_equal_to(send_insn_id, ccall);
+                        fun.push_insn(block, Insn::PopOpnds { count: args_count });
                         return Ok(());
                     }
                     // Fall through for complex cases (splat, kwargs, etc.)
@@ -2454,19 +2456,20 @@ impl Function {
                 worklist.push_back(val);
                 worklist.push_back(state);
             }
+            &Insn::CCallVariadic { args_ptr, state, .. } => {
+                worklist.push_back(args_ptr);
+                worklist.push_back(state);
+            }
             &Insn::Send { recv, ref args, state, .. }
             | &Insn::SendForward { recv, ref args, state, .. }
             | &Insn::SendWithoutBlock { recv, ref args, state, .. }
-            | &Insn::CCallVariadic { recv, ref args, state, .. }
             | &Insn::SendWithoutBlockDirect { recv, ref args, state, .. }
             | &Insn::InvokeSuper { recv, ref args, state, .. } => {
                 worklist.push_back(recv);
                 worklist.extend(args);
                 worklist.push_back(state);
             }
-            &Insn::PushOpnds { ref opnds } => {
-                worklist.extend(opnds);
-            }
+            Insn::PushOpnds { opnds } => worklist.extend(opnds),
             &Insn::InvokeBuiltin { ref args, state, .. }
             | &Insn::InvokeBlock { ref args, state, .. } => {
                 worklist.extend(args);