ZJIT: Optimize super calls to C function targets

Author: nirvdrum

test/ruby/test_zjit.rb

@@ -1096,16 +1096,68 @@ def test
     }, call_threshold: 2
   end
 
-  def test_invokesuper_to_cfunc
-    assert_compiles '["MyArray", 3]', %q{
-      class MyArray < Array
+  def test_invokesuper_to_cfunc_no_args
+    assert_compiles '["MyString", 3]', %q{
+      class MyString < String
         def length
-          ["MyArray", super]
+          ["MyString", super]
         end
       end
 
       def test
-        MyArray.new([1, 2, 3]).length
+        MyString.new("abc").length
+      end
+
+      test  # profile invokesuper
+      test  # compile + run compiled code
+    }, call_threshold: 2
+  end
+
+  def test_invokesuper_to_cfunc_simple_args
+    assert_compiles '["MyString", true]', %q{
+      class MyString < String
+        def include?(other)
+          ["MyString", super(other)]
+        end
+      end
+
+      def test
+        MyString.new("abc").include?("bc")
+      end
+
+      test  # profile invokesuper
+      test  # compile + run compiled code
+    }, call_threshold: 2
+  end
+
+
+  def test_invokesuper_to_cfunc_with_optional_arg
+    assert_compiles '["MyString", 6]', %q{
+      class MyString < String
+        def byteindex(needle, offset = 0)
+          ["MyString", super(needle, offset)]
+        end
+      end
+
+      def test
+        MyString.new("hello world").byteindex("world")
+      end
+
+      test  # profile invokesuper
+      test  # compile + run compiled code
+    }, call_threshold: 2
+  end
+
+  def test_invokesuper_to_cfunc_varargs
+    assert_compiles '["MyString", true]', %q{
+      class MyString < String
+        def end_with?(str)
+          ["MyString", super(str)]
+        end
+      end
+
+      def test
+        MyString.new("abc").end_with?("bc")
       end
 
       test  # profile invokesuper

zjit/src/hir.rs

@@ -1297,6 +1297,20 @@ fn get_local_var_name_for_printer(iseq: Option<IseqPtr>, level: u32, ep_offset:
     Some(format!(":{}", id.contents_lossy()))
 }
 
+/// Construct a qualified method name for display/debug output.
+/// Returns strings like "Array#length" for instance methods or "Foo.bar" for singleton methods.
+fn qualified_method_name(class: VALUE, method_id: ID) -> String {
+    let method_name = method_id.contents_lossy();
+    // rb_zjit_singleton_class_p also checks if it's a class
+    if unsafe { rb_zjit_singleton_class_p(class) } {
+        let class_name = get_class_name(unsafe { rb_class_attached_object(class) });
+        format!("{class_name}.{method_name}")
+    } else {
+        let class_name = get_class_name(class);
+        format!("{class_name}#{method_name}")
+    }
+}
+
 static REGEXP_FLAGS: &[(u32, &str)] = &[
     (ONIG_OPTION_MULTILINE, "MULTILINE"),
     (ONIG_OPTION_IGNORECASE, "IGNORECASE"),
@@ -3504,6 +3518,40 @@ impl Function {
                         };
                     }
                     Insn::InvokeSuper { recv, cd, blockiseq, args, state, .. } => {
+                        // Helper to emit common guards for super call optimization.
+                        fn emit_super_call_guards(
+                            fun: &mut Function,
+                            block: BlockId,
+                            super_cme: *const rb_callable_method_entry_t,
+                            current_cme: *const rb_callable_method_entry_t,
+                            mid: ID,
+                            state: InsnId,
+                        ) {
+                            fun.push_insn(block, Insn::PatchPoint {
+                                invariant: Invariant::MethodRedefined {
+                                    klass: unsafe { (*super_cme).defined_class },
+                                    method: mid,
+                                    cme: super_cme
+                                },
+                                state
+                            });
+
+                            let lep = fun.push_insn(block, Insn::GetLEP);
+                            fun.push_insn(block, Insn::GuardSuperMethodEntry {
+                                lep,
+                                cme: current_cme,
+                                state
+                            });
+
+                            let block_handler = fun.push_insn(block, Insn::GetBlockHandler { lep });
+                            fun.push_insn(block, Insn::GuardBitEquals {
+                                val: block_handler,
+                                expected: Const::Value(VALUE(VM_BLOCK_HANDLER_NONE as usize)),
+                                reason: SideExitReason::UnhandledBlockArg,
+                                state
+                            });
+                        }
+
                         // Don't handle calls with literal blocks (e.g., super { ... })
                         if !blockiseq.is_null() {
                             self.push_insn_id(block, insn_id);
@@ -3567,68 +3615,107 @@ impl Function {
                             continue;
                         }
 
-                        // Check if it's an ISEQ method; bail if it isn't.
                         let def_type = unsafe { get_cme_def_type(super_cme) };
-                        if def_type != VM_METHOD_TYPE_ISEQ {
-                            self.push_insn_id(block, insn_id);
-                            self.set_dynamic_send_reason(insn_id, SuperNotOptimizedMethodType(MethodType::from(def_type)));
-                            continue;
-                        }
 
-                        // Check if the super method's parameters support direct send.
-                        // If not, we can't do direct dispatch.
-                        let super_iseq = unsafe { get_def_iseq_ptr((*super_cme).def) };
-                        // TODO: pass Option<blockiseq> to can_direct_send when we start specializing super { ... }
-                        if !can_direct_send(self, block, super_iseq, ci, insn_id, args.as_slice(), None) {
-                            self.push_insn_id(block, insn_id);
-                            self.set_dynamic_send_reason(insn_id, SuperTargetComplexArgsPass);
-                            continue;
-                        }
+                        if def_type == VM_METHOD_TYPE_ISEQ {
+                            // Check if the super method's parameters support direct send.
+                            // If not, we can't do direct dispatch.
+                            let super_iseq = unsafe { get_def_iseq_ptr((*super_cme).def) };
+                            // TODO: pass Option<blockiseq> to can_direct_send when we start specializing `super { ... }`.
+                            if !can_direct_send(self, block, super_iseq, ci, insn_id, args.as_slice(), None) {
+                                self.push_insn_id(block, insn_id);
+                                self.set_dynamic_send_reason(insn_id, SuperTargetComplexArgsPass);
+                                continue;
+                            }
 
-                        // Add PatchPoint for method redefinition.
-                        self.push_insn(block, Insn::PatchPoint {
-                            invariant: Invariant::MethodRedefined {
-                                klass: unsafe { (*super_cme).defined_class },
-                                method: mid,
-                                cme: super_cme
-                            },
-                            state
-                        });
+                            let Ok((send_state, processed_args, kw_bits)) = self.prepare_direct_send_args(block, &args, ci, super_iseq, state)
+                                .inspect_err(|&reason| self.set_dynamic_send_reason(insn_id, reason)) else {
+                                self.push_insn_id(block, insn_id); continue;
+                            };
 
-                        // Guard that we're calling `super` from the expected method context.
-                        let lep = self.push_insn(block, Insn::GetLEP);
-                        self.push_insn(block, Insn::GuardSuperMethodEntry {
-                            lep,
-                            cme: current_cme,
-                            state
-                        });
+                            emit_super_call_guards(self, block, super_cme, current_cme, mid, state);
 
-                        // Guard that no block is being passed (implicit or explicit).
-                        let block_handler = self.push_insn(block, Insn::GetBlockHandler { lep });
-                        self.push_insn(block, Insn::GuardBitEquals {
-                            val: block_handler,
-                            expected: Const::Value(VALUE(VM_BLOCK_HANDLER_NONE as usize)),
-                            reason: SideExitReason::UnhandledBlockArg,
-                            state
-                        });
+                            // Use SendDirect with the super method's CME and ISEQ.
+                            let send_direct = self.push_insn(block, Insn::SendDirect {
+                                recv,
+                                cd,
+                                cme: super_cme,
+                                iseq: super_iseq,
+                                args: processed_args,
+                                kw_bits,
+                                state: send_state,
+                                blockiseq: None,
+                            });
+                            self.make_equal_to(insn_id, send_direct);
 
-                        let Ok((send_state, processed_args, kw_bits)) = self.prepare_direct_send_args(block, &args, ci, super_iseq, state)
-                            .inspect_err(|&reason| self.set_dynamic_send_reason(insn_id, reason)) else {
-                            self.push_insn_id(block, insn_id); continue;
-                        };
+                        } else if def_type == VM_METHOD_TYPE_CFUNC {
+                            let cfunc = unsafe { get_cme_def_body_cfunc(super_cme) };
+                            let cfunc_argc = unsafe { get_mct_argc(cfunc) };
+                            let cfunc_ptr = unsafe { get_mct_func(cfunc) }.cast();
+
+                            match cfunc_argc {
+                                // C function with fixed argument count.
+                                0.. => {
+                                    // Check argc matches
+                                    if args.len() != cfunc_argc as usize {
+                                        self.push_insn_id(block, insn_id);
+                                        self.set_dynamic_send_reason(insn_id, ArgcParamMismatch);
+                                        continue;
+                                    }
 
-                        // Use SendDirect with the super method's CME and ISEQ.
-                        let send_direct = self.push_insn(block, Insn::SendDirect {
-                            recv,
-                            cd,
-                            cme: super_cme,
-                            iseq: super_iseq,
-                            args: processed_args,
-                            kw_bits,
-                            state: send_state,
-                            blockiseq: None,
-                        });
-                        self.make_equal_to(insn_id, send_direct);
+                                    emit_super_call_guards(self, block, super_cme, current_cme, mid, state);
+
+                                    // Use CCallWithFrame for the C function.
+                                    let name = rust_str_to_id(&qualified_method_name(unsafe { (*super_cme).owner }, unsafe { (*super_cme).called_id }));
+                                    let ccall = self.push_insn(block, Insn::CCallWithFrame {
+                                        cd,
+                                        cfunc: cfunc_ptr,
+                                        recv,
+                                        args: args.clone(),
+                                        cme: super_cme,
+                                        name,
+                                        state,
+                                        return_type: types::BasicObject,
+                                        elidable: false,
+                                        blockiseq: None,
+                                    });
+                                    self.make_equal_to(insn_id, ccall);
+                                }
+
+                                // Variadic C function: func(int argc, VALUE *argv, VALUE recv)
+                                -1 => {
+                                    emit_super_call_guards(self, block, super_cme, current_cme, mid, state);
+
+                                    // Use CCallVariadic for the variadic C function.
+                                    let name = rust_str_to_id(&qualified_method_name(unsafe { (*super_cme).owner }, unsafe { (*super_cme).called_id }));
+                                    let ccall = self.push_insn(block, Insn::CCallVariadic {
+                                        cfunc: cfunc_ptr,
+                                        recv,
+                                        args: args.clone(),
+                                        cme: super_cme,
+                                        name,
+                                        state,
+                                        return_type: types::BasicObject,
+                                        elidable: false,
+                                        blockiseq: None,
+                                    });
+                                    self.make_equal_to(insn_id, ccall);
+                                }
+
+                                // Array-variadic: (self, args_ruby_array).
+                                -2 => {
+                                    self.push_insn_id(block, insn_id);
+                                    self.set_dynamic_send_reason(insn_id, SuperNotOptimizedMethodType(MethodType::Cfunc));
+                                    continue;
+                                }
+                                _ => unreachable!("unknown cfunc argc: {}", cfunc_argc)
+                            }
+                        } else {
+                            // Other method types (not ISEQ or CFUNC)
+                            self.push_insn_id(block, insn_id);
+                            self.set_dynamic_send_reason(insn_id, SuperNotOptimizedMethodType(MethodType::from(def_type)));
+                            continue;
+                        }
                     }
                     _ => { self.push_insn_id(block, insn_id); }
                 }
@@ -4296,18 +4383,6 @@ impl Function {
             Err(())
         }
 
-        fn qualified_method_name(class: VALUE, method_id: ID) -> String {
-            let method_name = method_id.contents_lossy();
-            // rb_zjit_singleton_class_p also checks if it's a class
-            if unsafe { rb_zjit_singleton_class_p(class) } {
-                let class_name = get_class_name(unsafe { rb_class_attached_object(class) });
-                format!("{class_name}.{method_name}")
-            } else {
-                let class_name = get_class_name(class);
-                format!("{class_name}#{method_name}")
-            }
-        }
-
         fn count_not_inlined_cfunc(fun: &mut Function, block: BlockId, cme: *const rb_callable_method_entry_t) {
             let owner = unsafe { (*cme).owner };
             let called_id = unsafe { (*cme).called_id };