ZJIT: Report stats for unhandled call types

tekknolagi · tekknolagi · commit 99bf47ab8c3f · 2025-08-29T10:42:39.000-07:00
diff --git a/zjit.rb b/zjit.rb
@@ -35,6 +35,7 @@ def stats_string
     stats = self.stats
 
     print_counters_with_prefix(prefix: 'failed_', prompt: 'compilation failure reasons', buf:, stats:)
+    print_counters_with_prefix(prefix: 'unhandled_call_', prompt: 'unhandled call types', buf:, stats:, limit: 20)
     print_counters([
       :dynamic_send_count,
 
diff --git a/zjit/src/backend/lir.rs b/zjit/src/backend/lir.rs
@@ -6,7 +6,7 @@ use crate::cruby::{Qundef, RUBY_OFFSET_CFP_PC, RUBY_OFFSET_CFP_SP, SIZEOF_VALUE_
 use crate::hir::SideExitReason;
 use crate::options::{debug, get_option};
 use crate::cruby::VALUE;
-use crate::stats::{exit_counter_ptr, exit_counter_ptr_for_opcode};
+use crate::stats::{exit_counter_ptr, exit_counter_ptr_for_opcode, exit_counter_ptr_for_call_type};
 use crate::virtualmem::CodePtr;
 use crate::asm::{CodeBlock, Label};
 
@@ -1604,6 +1604,11 @@ impl Assembler
                         self.load_into(SCRATCH_OPND, Opnd::const_ptr(exit_counter_ptr_for_opcode(opcode)));
                         self.incr_counter_with_reg(Opnd::mem(64, SCRATCH_OPND, 0), 1.into(), C_RET_OPND);
                     }
+                    if let SideExitReason::UnhandledCallType(call_type) = reason {
+                        asm_comment!(self, "increment an unknown call type counter");
+                        self.load_into(SCRATCH_OPND, Opnd::const_ptr(exit_counter_ptr_for_call_type(call_type)));
+                        self.incr_counter_with_reg(Opnd::mem(64, SCRATCH_OPND, 0), 1.into(), C_RET_OPND);
+                    }
                 }
 
                 asm_comment!(self, "exit to the interpreter");
diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
@@ -439,7 +439,7 @@ impl PtrPrintMap {
 #[derive(Debug, Clone, Copy)]
 pub enum SideExitReason {
     UnknownNewarraySend(vm_opt_newarray_send_type),
-    UnknownCallType,
+    UnhandledCallType(CallType),
     UnknownSpecialVariable(u64),
     UnhandledHIRInsn(InsnId),
     UnhandledYARVInsn(u32),
@@ -2808,7 +2808,7 @@ fn compute_bytecode_info(iseq: *const rb_iseq_t) -> BytecodeInfo {
     BytecodeInfo { jump_targets: result, has_send }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum CallType {
     Splat,
     BlockArg,
@@ -2846,19 +2846,19 @@ fn num_locals(iseq: *const rb_iseq_t) -> usize {
 }
 
 /// If we can't handle the type of send (yet), bail out.
-fn unknown_call_type(flag: u32) -> bool {
-    if (flag & VM_CALL_KW_SPLAT_MUT) != 0 { return true; }
-    if (flag & VM_CALL_ARGS_SPLAT_MUT) != 0 { return true; }
-    if (flag & VM_CALL_ARGS_SPLAT) != 0 { return true; }
-    if (flag & VM_CALL_KW_SPLAT) != 0 { return true; }
-    if (flag & VM_CALL_ARGS_BLOCKARG) != 0 { return true; }
-    if (flag & VM_CALL_KWARG) != 0 { return true; }
-    if (flag & VM_CALL_TAILCALL) != 0 { return true; }
-    if (flag & VM_CALL_SUPER) != 0 { return true; }
-    if (flag & VM_CALL_ZSUPER) != 0 { return true; }
-    if (flag & VM_CALL_OPT_SEND) != 0 { return true; }
-    if (flag & VM_CALL_FORWARDING) != 0 { return true; }
-    false
+fn unknown_call_type(flag: u32) -> Result<(), CallType> {
+    if (flag & VM_CALL_KW_SPLAT_MUT) != 0 { return Err(CallType::KwSplatMut); }
+    if (flag & VM_CALL_ARGS_SPLAT_MUT) != 0 { return Err(CallType::SplatMut); }
+    if (flag & VM_CALL_ARGS_SPLAT) != 0 { return Err(CallType::Splat); }
+    if (flag & VM_CALL_KW_SPLAT) != 0 { return Err(CallType::KwSplat); }
+    if (flag & VM_CALL_ARGS_BLOCKARG) != 0 { return Err(CallType::BlockArg); }
+    if (flag & VM_CALL_KWARG) != 0 { return Err(CallType::Kwarg); }
+    if (flag & VM_CALL_TAILCALL) != 0 { return Err(CallType::Tailcall); }
+    if (flag & VM_CALL_SUPER) != 0 { return Err(CallType::Super); }
+    if (flag & VM_CALL_ZSUPER) != 0 { return Err(CallType::Zsuper); }
+    if (flag & VM_CALL_OPT_SEND) != 0 { return Err(CallType::OptSend); }
+    if (flag & VM_CALL_FORWARDING) != 0 { return Err(CallType::Forwarding); }
+    Ok(())
 }
 
 /// We have IseqPayload, which keeps track of HIR Types in the interpreter, but this is not useful
@@ -3324,10 +3324,10 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     // NB: opt_neq has two cd; get_arg(0) is for eq and get_arg(1) is for neq
                     let cd: *const rb_call_data = get_arg(pc, 1).as_ptr();
                     let call_info = unsafe { rb_get_call_data_ci(cd) };
-                    if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
+                    if let Err(call_type) = unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
                         // Unknown call type; side-exit into the interpreter
                         let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
-                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnknownCallType });
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnhandledCallType(call_type) });
                         break;  // End the block
                     }
                     let argc = unsafe { vm_ci_argc((*cd).ci) };
@@ -3345,10 +3345,10 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     // NB: these instructions have the recv for the call at get_arg(0)
                     let cd: *const rb_call_data = get_arg(pc, 1).as_ptr();
                     let call_info = unsafe { rb_get_call_data_ci(cd) };
-                    if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
+                    if let Err(call_type) = unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
                         // Unknown call type; side-exit into the interpreter
                         let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
-                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnknownCallType });
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnhandledCallType(call_type) });
                         break;  // End the block
                     }
                     let argc = unsafe { vm_ci_argc((*cd).ci) };
@@ -3403,10 +3403,10 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                 YARVINSN_opt_send_without_block => {
                     let cd: *const rb_call_data = get_arg(pc, 0).as_ptr();
                     let call_info = unsafe { rb_get_call_data_ci(cd) };
-                    if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
+                    if let Err(call_type) = unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
                         // Unknown call type; side-exit into the interpreter
                         let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
-                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnknownCallType });
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnhandledCallType(call_type) });
                         break;  // End the block
                     }
                     let argc = unsafe { vm_ci_argc((*cd).ci) };
@@ -3421,10 +3421,10 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     let cd: *const rb_call_data = get_arg(pc, 0).as_ptr();
                     let blockiseq: IseqPtr = get_arg(pc, 1).as_iseq();
                     let call_info = unsafe { rb_get_call_data_ci(cd) };
-                    if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
+                    if let Err(call_type) = unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
                         // Unknown call type; side-exit into the interpreter
                         let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
-                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnknownCallType });
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnhandledCallType(call_type) });
                         break;  // End the block
                     }
                     let argc = unsafe { vm_ci_argc((*cd).ci) };
@@ -3549,8 +3549,8 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     let cd: *const rb_call_data = get_arg(pc, 0).as_ptr();
                     let call_info = unsafe { rb_get_call_data_ci(cd) };
 
-                    if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
-                        assert!(false, "objtostring should not have unknown call type");
+                    if let Err(call_type) = unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {
+                        assert!(false, "objtostring should not have unknown call type {call_type:?}");
                     }
                     let argc = unsafe { vm_ci_argc((*cd).ci) };
                     assert_eq!(0, argc, "objtostring should not have args");
@@ -4872,12 +4872,12 @@ mod tests {
         eval("
             def test(a) = foo(*a)
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:2:
-            bb0(v0:BasicObject, v1:BasicObject):
-              v4:ArrayExact = ToArray v1
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0(v0:BasicObject, v1:BasicObject):
+          v4:ArrayExact = ToArray v1
+          SideExit UnhandledCallType(Splat)
+        ");
     }
 
     #[test]
@@ -4889,7 +4889,7 @@ mod tests {
         fn test@<compiled>:2:
         bb0(v0:BasicObject, v1:BasicObject):
           v3:BasicObject = GetLocal l0, EP@3
-          SideExit UnknownCallType
+          SideExit UnhandledCallType(BlockArg)
         ");
     }
 
@@ -4898,24 +4898,24 @@ mod tests {
         eval("
             def test(a) = foo(a: 1)
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:2:
-            bb0(v0:BasicObject, v1:BasicObject):
-              v3:Fixnum[1] = Const Value(1)
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0(v0:BasicObject, v1:BasicObject):
+          v3:Fixnum[1] = Const Value(1)
+          SideExit UnhandledCallType(Kwarg)
+        ");
     }
 
     #[test]
     fn test_cant_compile_kw_splat() {
         eval("
             def test(a) = foo(**a)
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:2:
-            bb0(v0:BasicObject, v1:BasicObject):
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0(v0:BasicObject, v1:BasicObject):
+          SideExit UnhandledCallType(KwSplat)
+        ");
     }
 
     // TODO(max): Figure out how to generate a call with TAILCALL flag
@@ -4965,33 +4965,33 @@ mod tests {
         eval("
             def test(a) = foo **a, b: 1
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:2:
-            bb0(v0:BasicObject, v1:BasicObject):
-              v3:Class[VMFrozenCore] = Const Value(VALUE(0x1000))
-              v5:HashExact = NewHash
-              v7:BasicObject = SendWithoutBlock v3, :core#hash_merge_kwd, v5, v1
-              v8:Class[VMFrozenCore] = Const Value(VALUE(0x1000))
-              v9:StaticSymbol[:b] = Const Value(VALUE(0x1008))
-              v10:Fixnum[1] = Const Value(1)
-              v12:BasicObject = SendWithoutBlock v8, :core#hash_merge_ptr, v7, v9, v10
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0(v0:BasicObject, v1:BasicObject):
+          v3:Class[VMFrozenCore] = Const Value(VALUE(0x1000))
+          v5:HashExact = NewHash
+          v7:BasicObject = SendWithoutBlock v3, :core#hash_merge_kwd, v5, v1
+          v8:Class[VMFrozenCore] = Const Value(VALUE(0x1000))
+          v9:StaticSymbol[:b] = Const Value(VALUE(0x1008))
+          v10:Fixnum[1] = Const Value(1)
+          v12:BasicObject = SendWithoutBlock v8, :core#hash_merge_ptr, v7, v9, v10
+          SideExit UnhandledCallType(KwSplatMut)
+        ");
     }
 
     #[test]
     fn test_cant_compile_splat_mut() {
         eval("
             def test(*) = foo *, 1
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:2:
-            bb0(v0:BasicObject, v1:ArrayExact):
-              v4:ArrayExact = ToNewArray v1
-              v5:Fixnum[1] = Const Value(1)
-              ArrayPush v4, v5
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0(v0:BasicObject, v1:ArrayExact):
+          v4:ArrayExact = ToNewArray v1
+          v5:Fixnum[1] = Const Value(1)
+          ArrayPush v4, v5
+          SideExit UnhandledCallType(SplatMut)
+        ");
     }
 
     #[test]
@@ -7398,12 +7398,12 @@ mod opt_tests {
             test
             test
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:3:
-            bb0(v0:BasicObject):
-              v2:Fixnum[1] = Const Value(1)
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:3:
+        bb0(v0:BasicObject):
+          v2:Fixnum[1] = Const Value(1)
+          SideExit UnhandledCallType(Kwarg)
+        ");
     }
 
     #[test]
@@ -7414,12 +7414,12 @@ mod opt_tests {
             test
             test
         ");
-        assert_snapshot!(hir_string("test"), @r#"
-            fn test@<compiled>:3:
-            bb0(v0:BasicObject):
-              v2:Fixnum[1] = Const Value(1)
-              SideExit UnknownCallType
-        "#);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:3:
+        bb0(v0:BasicObject):
+          v2:Fixnum[1] = Const Value(1)
+          SideExit UnhandledCallType(Kwarg)
+        ");
     }
 
     #[test]
diff --git a/zjit/src/stats.rs b/zjit/src/stats.rs
@@ -85,7 +85,7 @@ make_counters! {
         // exit_: Side exits reasons
         exit_compilation_failure,
         exit_unknown_newarray_send,
-        exit_unknown_call_type,
+        exit_unhandled_call_type,
         exit_unknown_special_variable,
         exit_unhandled_hir_insn,
         exit_unhandled_yarv_insn,
@@ -101,6 +101,19 @@ make_counters! {
         exit_interrupt,
     }
 
+    // unhanded_call_: Unhandled call types
+    unhandled_call_splat,
+    unhandled_call_block_arg,
+    unhandled_call_kwarg,
+    unhandled_call_kw_splat,
+    unhandled_call_tailcall,
+    unhandled_call_super,
+    unhandled_call_zsuper,
+    unhandled_call_optsend,
+    unhandled_call_kw_splat_mut,
+    unhandled_call_splat_mut,
+    unhandled_call_forwarding,
+
     // failed_: Compilation failure reasons
     failed_iseq_stack_too_large,
     failed_hir_compile,
@@ -138,12 +151,32 @@ pub fn exit_counter_ptr_for_opcode(opcode: u32) -> *mut u64 {
     unsafe { exit_counters.get_unchecked_mut(opcode as usize) }
 }
 
+/// Return a raw pointer to the exit counter for a given call type
+pub fn exit_counter_ptr_for_call_type(call_type: crate::hir::CallType) -> *mut u64 {
+    use crate::hir::CallType::*;
+    use crate::stats::Counter::*;
+    let counter = match call_type {
+        Splat      => unhandled_call_splat,
+        BlockArg   => unhandled_call_block_arg,
+        Kwarg      => unhandled_call_kwarg,
+        KwSplat    => unhandled_call_kw_splat,
+        Tailcall   => unhandled_call_tailcall,
+        Super      => unhandled_call_super,
+        Zsuper     => unhandled_call_zsuper,
+        OptSend    => unhandled_call_optsend,
+        KwSplatMut => unhandled_call_kw_splat_mut,
+        SplatMut   => unhandled_call_splat_mut,
+        Forwarding => unhandled_call_forwarding,
+    };
+    counter_ptr(counter)
+}
+
 pub fn exit_counter_ptr(reason: crate::hir::SideExitReason) -> *mut u64 {
     use crate::hir::SideExitReason::*;
     use crate::stats::Counter::*;
     let counter = match reason {
         UnknownNewarraySend(_)    => exit_unknown_newarray_send,
-        UnknownCallType           => exit_unknown_call_type,
+        UnhandledCallType(_)      => exit_unhandled_call_type,
         UnknownSpecialVariable(_) => exit_unknown_special_variable,
         UnhandledHIRInsn(_)       => exit_unhandled_hir_insn,
         UnhandledYARVInsn(_)      => exit_unhandled_yarv_insn,
