ZJIT: Add compilation for checkkeyword (#14764)

<details>
<summary>Before</summary>
<br>

```
**ZJIT: Printing ZJIT statistics on exit***
Top-20 not inlined C methods (64.0% of total 3,683,424):
                               Kernel#is_a?: 427,127 (11.6%)
                                   Hash#[]=: 426,276 (11.6%)
                         String#start_with?: 336,245 ( 9.1%)
                 ObjectSpace::WeakKeyMap#[]: 139,406 ( 3.8%)
                                 Hash#fetch: 127,291 ( 3.5%)
                                String#hash:  79,259 ( 2.2%)
                      Process.clock_gettime:  74,658 ( 2.0%)
                                 Array#any?:  74,441 ( 2.0%)
                                 Integer#==:  71,067 ( 1.9%)
                                 Kernel#dup:  68,058 ( 1.8%)
                                  Hash#key?:  62,306 ( 1.7%)
                              Regexp#match?:  62,247 ( 1.7%)
                    SQLite3::Statement#step:  61,172 ( 1.7%)
                   SQLite3::Statement#done?:  61,172 ( 1.7%)
                               Kernel#Array:  55,015 ( 1.5%)
                                Integer#<=>:  49,127 ( 1.3%)
                                 String.new:  48,363 ( 1.3%)
                                    IO#read:  47,753 ( 1.3%)
                             Array#include?:  43,307 ( 1.2%)
                          Struct#initialize:  42,650 ( 1.2%)
Top-3 not optimized method types for send (100.0% of total 1,022,743):
   iseq: 736,483 (72.0%)
  cfunc: 286,174 (28.0%)
   null:      86 ( 0.0%)
Top-6 not optimized method types for send_without_block (100.0% of total 189,556):
         optimized_call: 115,966 (61.2%)
         optimized_send:  36,767 (19.4%)
  optimized_struct_aset:  33,788 (17.8%)
                   null:   2,521 ( 1.3%)
   optimized_block_call:     510 ( 0.3%)
                  cfunc:       4 ( 0.0%)
Top-13 not optimized instructions (100.0% of total 1,648,882):
             invokesuper: 697,471 (42.3%)
             invokeblock: 496,687 (30.1%)
             sendforward: 221,094 (13.4%)
                  opt_eq: 147,620 ( 9.0%)
               opt_minus:  40,865 ( 2.5%)
                opt_plus:  22,912 ( 1.4%)
  opt_send_without_block:  18,932 ( 1.1%)
                  opt_gt:     867 ( 0.1%)
                opt_mult:     768 ( 0.0%)
                 opt_neq:     654 ( 0.0%)
                  opt_or:     508 ( 0.0%)
                  opt_lt:     359 ( 0.0%)
                  opt_ge:     145 ( 0.0%)
Top-13 send fallback reasons (100.0% of total 8,308,826):
                          send_without_block_polymorphic: 3,174,975 (38.2%)
                               not_optimized_instruction: 1,648,882 (19.8%)
                                      fancy_call_feature: 1,072,807 (12.9%)
                          send_not_optimized_method_type: 1,022,743 (12.3%)
                                        send_no_profiles:   599,715 ( 7.2%)
                          send_without_block_no_profiles:   486,108 ( 5.9%)
  send_without_block_not_optimized_optimized_method_type:   187,031 ( 2.3%)
                                        send_polymorphic:   101,834 ( 1.2%)
                                obj_to_string_not_string:     7,610 ( 0.1%)
            send_without_block_not_optimized_method_type:     2,525 ( 0.0%)
                 send_without_block_direct_too_many_args:     2,369 ( 0.0%)
                 send_without_block_cfunc_array_variadic:     2,190 ( 0.0%)
                          ccall_with_frame_too_many_args:        37 ( 0.0%)
Top-8 popular unsupported argument-parameter features (100.0% of total 1,209,121):
          param_opt: 583,595 (48.3%)
  param_forwardable: 178,162 (14.7%)
        param_block: 162,689 (13.5%)
           param_kw: 150,575 (12.5%)
         param_rest:  90,091 ( 7.5%)
       param_kwrest:  33,791 ( 2.8%)
       caller_splat:  10,214 ( 0.8%)
    caller_kw_splat:       4 ( 0.0%)
Top-7 unhandled YARV insns (100.0% of total 128,032):
        checkkeyword: 88,698 (69.3%)
  invokesuperforward: 22,296 (17.4%)
       getblockparam: 16,292 (12.7%)
         getconstant:    336 ( 0.3%)
          checkmatch:    290 ( 0.2%)
       setblockparam:    101 ( 0.1%)
                once:     19 ( 0.0%)
Top-1 compile error reasons (100.0% of total 21,283):
  exception_handler: 21,283 (100.0%)
Top-18 side exit reasons (100.0% of total 2,335,562):
                   guard_type_failure: 677,930 (29.0%)
                  guard_shape_failure: 410,183 (17.6%)
                      unhandled_kwarg: 235,100 (10.1%)
     patchpoint_stable_constant_names: 206,172 ( 8.8%)
  block_param_proxy_not_iseq_or_ifunc: 199,931 ( 8.6%)
        patchpoint_no_singleton_class: 188,359 ( 8.1%)
                  unhandled_yarv_insn: 128,032 ( 5.5%)
                unknown_newarray_send: 124,805 ( 5.3%)
          patchpoint_method_redefined:  73,062 ( 3.1%)
                   unhandled_hir_insn:  56,688 ( 2.4%)
                        compile_error:  21,283 ( 0.9%)
           block_param_proxy_modified:  11,647 ( 0.5%)
                 fixnum_mult_overflow:     954 ( 0.0%)
              patchpoint_no_ep_escape:     813 ( 0.0%)
             guard_bit_equals_failure:     316 ( 0.0%)
               obj_to_string_fallback:     230 ( 0.0%)
                            interrupt:      35 ( 0.0%)
               guard_type_not_failure:      22 ( 0.0%)
                             send_count: 26,775,579
                     dynamic_send_count:  8,308,826 (31.0%)
                   optimized_send_count: 18,466,753 (69.0%)
              iseq_optimized_send_count:  7,611,729 (28.4%)
      inline_cfunc_optimized_send_count:  5,935,290 (22.2%)
       inline_iseq_optimized_send_count:    657,555 ( 2.5%)
non_variadic_cfunc_optimized_send_count:  3,169,054 (11.8%)
    variadic_cfunc_optimized_send_count:  1,093,125 ( 4.1%)
dynamic_getivar_count:                        2,793,635
dynamic_setivar_count:                        3,040,844
compiled_iseq_count:                              4,496
failed_iseq_count:                                    0
compile_time:                                     915ms
profile_time:                                       6ms
gc_time:                                            6ms
invalidation_time:                                 20ms
vm_write_pc_count:                           26,857,114
vm_write_sp_count:                           25,770,558
vm_write_locals_count:                       25,770,558
vm_write_stack_count:                        25,770,558
vm_write_to_parent_iseq_local_count:            106,036
vm_read_from_parent_iseq_local_count:         3,213,992
guard_type_count:                            27,683,170
guard_type_exit_ratio:                             2.4%
code_region_bytes:                           32,178,176
side_exit_count:                              2,335,562
total_insn_count:                           170,714,077
vm_insn_count:                               28,999,194
zjit_insn_count:                            141,714,883
ratio_in_zjit:                                    83.0%

```

</details>
<details>
<summary>After</summary>
<br>

```
**ZJIT: Printing ZJIT statistics on exit***
Top-20 not inlined C methods (63.9% of total 3,686,703):
                               Kernel#is_a?: 427,123 (11.6%)
                                   Hash#[]=: 426,276 (11.6%)
                         String#start_with?: 336,245 ( 9.1%)
                 ObjectSpace::WeakKeyMap#[]: 139,406 ( 3.8%)
                                 Hash#fetch: 127,291 ( 3.5%)
                                String#hash:  79,259 ( 2.1%)
                      Process.clock_gettime:  74,658 ( 2.0%)
                                 Array#any?:  74,441 ( 2.0%)
                                 Integer#==:  71,067 ( 1.9%)
                                 Kernel#dup:  68,058 ( 1.8%)
                              Regexp#match?:  62,336 ( 1.7%)
                                  Hash#key?:  62,306 ( 1.7%)
                    SQLite3::Statement#step:  61,172 ( 1.7%)
                   SQLite3::Statement#done?:  61,172 ( 1.7%)
                               Kernel#Array:  55,048 ( 1.5%)
                                Integer#<=>:  49,127 ( 1.3%)
                                 String.new:  48,363 ( 1.3%)
                                    IO#read:  47,753 ( 1.3%)
                             Array#include?:  43,309 ( 1.2%)
                          Struct#initialize:  42,650 ( 1.2%)
Top-3 not optimized method types for send (100.0% of total 1,026,413):
   iseq: 737,496 (71.9%)
  cfunc: 288,831 (28.1%)
   null:      86 ( 0.0%)
Top-6 not optimized method types for send_without_block (100.0% of total 189,556):
         optimized_call: 115,966 (61.2%)
         optimized_send:  36,767 (19.4%)
  optimized_struct_aset:  33,788 (17.8%)
                   null:   2,521 ( 1.3%)
   optimized_block_call:     510 ( 0.3%)
                  cfunc:       4 ( 0.0%)
Top-13 not optimized instructions (100.0% of total 1,648,949):
             invokesuper: 697,452 (42.3%)
             invokeblock: 496,687 (30.1%)
             sendforward: 221,094 (13.4%)
                  opt_eq: 147,620 ( 9.0%)
               opt_minus:  40,863 ( 2.5%)
                opt_plus:  22,912 ( 1.4%)
  opt_send_without_block:  19,020 ( 1.2%)
                  opt_gt:     867 ( 0.1%)
                opt_mult:     768 ( 0.0%)
                 opt_neq:     654 ( 0.0%)
                  opt_or:     508 ( 0.0%)
                  opt_lt:     359 ( 0.0%)
                  opt_ge:     145 ( 0.0%)
Top-13 send fallback reasons (100.0% of total 8,318,975):
                          send_without_block_polymorphic: 3,177,471 (38.2%)
                               not_optimized_instruction: 1,648,949 (19.8%)
                                      fancy_call_feature: 1,075,143 (12.9%)
                          send_not_optimized_method_type: 1,026,413 (12.3%)
                                        send_no_profiles:   599,748 ( 7.2%)
                          send_without_block_no_profiles:   486,190 ( 5.8%)
  send_without_block_not_optimized_optimized_method_type:   187,031 ( 2.2%)
                                        send_polymorphic:   102,497 ( 1.2%)
                                obj_to_string_not_string:     8,412 ( 0.1%)
            send_without_block_not_optimized_method_type:     2,525 ( 0.0%)
                 send_without_block_direct_too_many_args:     2,369 ( 0.0%)
                 send_without_block_cfunc_array_variadic:     2,190 ( 0.0%)
                          ccall_with_frame_too_many_args:        37 ( 0.0%)
Top-8 popular unsupported argument-parameter features (100.0% of total 1,211,457):
          param_opt: 584,073 (48.2%)
  param_forwardable: 178,907 (14.8%)
        param_block: 162,689 (13.4%)
           param_kw: 151,688 (12.5%)
         param_rest:  90,091 ( 7.4%)
       param_kwrest:  33,791 ( 2.8%)
       caller_splat:  10,214 ( 0.8%)
    caller_kw_splat:       4 ( 0.0%)
Top-6 unhandled YARV insns (100.0% of total 39,334):
  invokesuperforward: 22,296 (56.7%)
       getblockparam: 16,292 (41.4%)
         getconstant:    336 ( 0.9%)
          checkmatch:    290 ( 0.7%)
       setblockparam:    101 ( 0.3%)
                once:     19 ( 0.0%)
Top-1 compile error reasons (100.0% of total 21,283):
  exception_handler: 21,283 (100.0%)
Top-18 side exit reasons (100.0% of total 2,253,541):
                   guard_type_failure: 682,695 (30.3%)
                  guard_shape_failure: 410,183 (18.2%)
                      unhandled_kwarg: 236,780 (10.5%)
     patchpoint_stable_constant_names: 206,310 ( 9.2%)
  block_param_proxy_not_iseq_or_ifunc: 199,931 ( 8.9%)
        patchpoint_no_singleton_class: 188,438 ( 8.4%)
                unknown_newarray_send: 124,805 ( 5.5%)
          patchpoint_method_redefined:  73,056 ( 3.2%)
                   unhandled_hir_insn:  56,686 ( 2.5%)
                  unhandled_yarv_insn:  39,334 ( 1.7%)
                        compile_error:  21,283 ( 0.9%)
           block_param_proxy_modified:  11,647 ( 0.5%)
                 fixnum_mult_overflow:     954 ( 0.0%)
              patchpoint_no_ep_escape:     813 ( 0.0%)
             guard_bit_equals_failure:     316 ( 0.0%)
               obj_to_string_fallback:     230 ( 0.0%)
                            interrupt:      58 ( 0.0%)
               guard_type_not_failure:      22 ( 0.0%)
                             send_count: 27,032,751
                     dynamic_send_count:  8,318,975 (30.8%)
                   optimized_send_count: 18,713,776 (69.2%)
              iseq_optimized_send_count:  7,809,698 (28.9%)
      inline_cfunc_optimized_send_count:  5,980,083 (22.1%)
       inline_iseq_optimized_send_count:    657,677 ( 2.4%)
non_variadic_cfunc_optimized_send_count:  3,170,381 (11.7%)
    variadic_cfunc_optimized_send_count:  1,095,937 ( 4.1%)
dynamic_getivar_count:                        2,793,987
dynamic_setivar_count:                        3,350,905
compiled_iseq_count:                              4,498
failed_iseq_count:                                    0
compile_time:                                     884ms
profile_time:                                       6ms
gc_time:                                            6ms
invalidation_time:                                 19ms
vm_write_pc_count:                           27,417,915
vm_write_sp_count:                           26,327,928
vm_write_locals_count:                       26,327,928
vm_write_stack_count:                        26,327,928
vm_write_to_parent_iseq_local_count:            106,036
vm_read_from_parent_iseq_local_count:         3,213,992
guard_type_count:                            27,937,831
guard_type_exit_ratio:                             2.4%
code_region_bytes:                           32,571,392
side_exit_count:                              2,253,541
total_insn_count:                           170,630,429
vm_insn_count:                               26,617,244
zjit_insn_count:                            144,013,185
ratio_in_zjit:                                    84.4%

```

</details>

4 files changed, 131 insertions, 1 deletions

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index fd34b6e0df..3ef93ee3d9 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -433,6 +433,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::SetClassVar { id, val, ic, state } => no_output!(gen_setclassvar(jit, asm, *id, opnd!(val), *ic, &function.frame_state(*state))),
         Insn::SetIvar { self_val, id, val, state } => no_output!(gen_setivar(jit, asm, opnd!(self_val), *id, opnd!(val), &function.frame_state(*state))),
         Insn::SetInstanceVariable { self_val, id, ic, val, state } => no_output!(gen_set_instance_variable(jit, asm, opnd!(self_val), *id, *ic, opnd!(val), &function.frame_state(*state))),
+        Insn::FixnumBitCheck { val, index } => gen_fixnum_bit_check(asm, opnd!(val), *index),
         Insn::SideExit { state, reason } => no_output!(gen_side_exit(jit, asm, reason, &function.frame_state(*state))),
         Insn::PutSpecialObject { value_type } => gen_putspecialobject(asm, *value_type),
         Insn::AnyToString { val, str, state } => gen_anytostring(asm, opnd!(val), opnd!(str), &function.frame_state(*state)),
@@ -652,6 +653,12 @@ fn gen_get_constant_path(jit: &JITState, asm: &mut Assembler, ic: *const iseq_in
     asm_ccall!(asm, rb_vm_opt_getconstant_path, EC, CFP, Opnd::const_ptr(ic))
 }
 
+fn gen_fixnum_bit_check(asm: &mut Assembler, val: Opnd, index: u8) -> Opnd {
+    let bit_test: u64 = 0x01 << (index + 1);
+    asm.test(val, bit_test.into());
+    asm.csel_z(Qtrue.into(), Qfalse.into())
+}
+
 fn gen_invokebuiltin(jit: &JITState, asm: &mut Assembler, state: &FrameState, bf: &rb_builtin_function, leaf: bool, args: Vec<Opnd>) -> lir::Opnd {
     assert!(bf.argc + 2 <= C_ARG_OPNDS.len() as i32,
             "gen_invokebuiltin should not be called for builtin function {} with too many arguments: {}",
diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
index 5a15aac06c..7c180929ab 100644
--- a/zjit/src/hir.rs
+++ b/zjit/src/hir.rs
@@ -462,6 +462,7 @@ pub enum SideExitReason {
     UnhandledHIRInsn(InsnId),
     UnhandledYARVInsn(u32),
     UnhandledCallType(CallType),
+    TooManyKeywordParameters,
     FixnumAddOverflow,
     FixnumSubOverflow,
     FixnumMultOverflow,
@@ -664,6 +665,9 @@ pub enum Insn {
     /// Kernel#block_given? but without pushing a frame. Similar to [`Insn::Defined`] with
     /// `DEFINED_YIELD`
     IsBlockGiven,
+    /// Test the bit at index of val, a Fixnum.
+    /// Return Qtrue if the bit is set, else Qfalse.
+    FixnumBitCheck { val: InsnId, index: u8 },
 
     /// Get a global variable named `id`
     GetGlobal { id: ID, state: InsnId },
@@ -1147,6 +1151,7 @@ impl<'a> std::fmt::Display for InsnPrinter<'a> {
             Insn::PatchPoint { invariant, .. } => { write!(f, "PatchPoint {}", invariant.print(self.ptr_map)) },
             Insn::GetConstantPath { ic, .. } => { write!(f, "GetConstantPath {:p}", self.ptr_map.map_ptr(ic)) },
             Insn::IsBlockGiven => { write!(f, "IsBlockGiven") },
+            Insn::FixnumBitCheck {val, index} => { write!(f, "FixnumBitCheck {val}, {index}") },
             Insn::CCall { cfunc, args, name, return_type: _, elidable: _ } => {
                 write!(f, "CCall {}@{:p}", name.contents_lossy(), self.ptr_map.map_ptr(cfunc))?;
                 for arg in args {
@@ -1691,6 +1696,7 @@ impl Function {
                     }
                 },
             &Return { val } => Return { val: find!(val) },
+            &FixnumBitCheck { val, index } => FixnumBitCheck { val: find!(val), index },
             &Throw { throw_state, val, state } => Throw { throw_state, val: find!(val), state },
             &StringCopy { val, chilled, state } => StringCopy { val: find!(val), chilled, state },
             &StringIntern { val, state } => StringIntern { val: find!(val), state: find!(state) },
@@ -1952,6 +1958,7 @@ impl Function {
             Insn::DefinedIvar { pushval, .. } => Type::from_value(*pushval).union(types::NilClass),
             Insn::GetConstantPath { .. } => types::BasicObject,
             Insn::IsBlockGiven => types::BoolExact,
+            Insn::FixnumBitCheck { .. } => types::BoolExact,
             Insn::ArrayMax { .. } => types::BasicObject,
             Insn::ArrayInclude { .. } => types::BoolExact,
             Insn::DupArrayInclude { .. } => types::BoolExact,
@@ -3245,6 +3252,9 @@ impl Function {
             | &Insn::GetConstantPath { ic: _, state } => {
                 worklist.push_back(state);
             }
+            &Insn::FixnumBitCheck { val, index: _ } => {
+                worklist.push_back(val)
+            }
             &Insn::ArrayMax { ref elements, state }
             | &Insn::NewHash { ref elements, state }
             | &Insn::NewArray { ref elements, state } => {
@@ -4648,6 +4658,22 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
                     state.stack_push(fun.push_insn(block, Insn::DefinedIvar { self_val: self_param, id, pushval, state: exit_id }));
                 }
+                YARVINSN_checkkeyword => {
+                    // When a keyword is unspecified past index 32, a hash will be used instead.
+                    // This can only happen in iseqs taking more than 32 keywords.
+                    // In this case, we side exit to the interpreter.
+                    // TODO(Jacob): Replace the magic number 32 with a named constant. (Can be completed after PR 15039)
+                    if unsafe {(*rb_get_iseq_body_param_keyword(iseq)).num >= 32} {
+                        let exit_id = fun.push_insn(block, Insn::Snapshot {state: exit_state});
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::TooManyKeywordParameters });
+                        break;
+                    }
+                    let ep_offset = get_arg(pc, 0).as_u32();
+                    let index = get_arg(pc, 1).as_u64();
+                    let index: u8 = index.try_into().map_err(|_| ParseError::MalformedIseq(insn_idx))?;
+                    let val = fun.push_insn(block, Insn::GetLocal { ep_offset, level: 0, use_sp: false, rest_param: false });
+                    state.stack_push(fun.push_insn(block, Insn::FixnumBitCheck { val, index }));
+                }
                 YARVINSN_opt_getconstant_path => {
                     let ic = get_arg(pc, 0).as_ptr();
                     let snapshot = fun.push_insn(block, Insn::Snapshot { state: exit_state });
diff --git a/zjit/src/hir/tests.rs b/zjit/src/hir/tests.rs
index af3fd3de91..accc104719 100644
--- a/zjit/src/hir/tests.rs
+++ b/zjit/src/hir/tests.rs
@@ -3273,4 +3273,99 @@ pub mod hir_build_tests {
           SideExit UnhandledYARVInsn(expandarray)
         ");
     }
-}
+
+    #[test]
+    fn test_checkkeyword_tests_fixnum_bit() {
+        eval(r#"
+            def test(kw: 1 + 1) = kw
+        "#);
+        assert_contains_opcode("test", YARVINSN_checkkeyword);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          v2:BasicObject = GetLocal l0, SP@5
+          v3:BasicObject = GetLocal l0, SP@4
+          Jump bb2(v1, v2, v3)
+        bb1(v6:BasicObject, v7:BasicObject, v8:BasicObject):
+          EntryPoint JIT(0)
+          Jump bb2(v6, v7, v8)
+        bb2(v10:BasicObject, v11:BasicObject, v12:BasicObject):
+          v14:BasicObject = GetLocal l0, EP@3
+          v15:BoolExact = FixnumBitCheck v14, 0
+          CheckInterrupts
+          v18:CBool = Test v15
+          IfTrue v18, bb3(v10, v11, v12)
+          v20:Fixnum[1] = Const Value(1)
+          v21:Fixnum[1] = Const Value(1)
+          v25:BasicObject = SendWithoutBlock v20, :+, v21
+          PatchPoint NoEPEscape(test)
+          Jump bb3(v10, v25, v12)
+        bb3(v29:BasicObject, v30:BasicObject, v31:BasicObject):
+          PatchPoint NoEPEscape(test)
+          CheckInterrupts
+          Return v30
+        ");
+    }
+
+    #[test]
+    fn test_checkkeyword_too_many_keywords_causes_side_exit() {
+        eval(r#"
+            def test(k1: k1, k2: k2, k3: k3, k4: k4, k5: k5,
+            k6: k6, k7: k7, k8: k8, k9: k9, k10: k10, k11: k11,
+            k12: k12, k13: k13, k14: k14, k15: k15, k16: k16,
+            k17: k17, k18: k18, k19: k19, k20: k20, k21: k21,
+            k22: k22, k23: k23, k24: k24, k25: k25, k26: k26,
+            k27: k27, k28: k28, k29: k29, k30: k30, k31: k31,
+            k32: k32, k33: k33) = k1
+        "#);
+        assert_contains_opcode("test", YARVINSN_checkkeyword);
+        assert_snapshot!(hir_string("test"), @r"
+        fn test@<compiled>:2:
+        bb0():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          v2:BasicObject = GetLocal l0, SP@37
+          v3:BasicObject = GetLocal l0, SP@36
+          v4:BasicObject = GetLocal l0, SP@35
+          v5:BasicObject = GetLocal l0, SP@34
+          v6:BasicObject = GetLocal l0, SP@33
+          v7:BasicObject = GetLocal l0, SP@32
+          v8:BasicObject = GetLocal l0, SP@31
+          v9:BasicObject = GetLocal l0, SP@30
+          v10:BasicObject = GetLocal l0, SP@29
+          v11:BasicObject = GetLocal l0, SP@28
+          v12:BasicObject = GetLocal l0, SP@27
+          v13:BasicObject = GetLocal l0, SP@26
+          v14:BasicObject = GetLocal l0, SP@25
+          v15:BasicObject = GetLocal l0, SP@24
+          v16:BasicObject = GetLocal l0, SP@23
+          v17:BasicObject = GetLocal l0, SP@22
+          v18:BasicObject = GetLocal l0, SP@21
+          v19:BasicObject = GetLocal l0, SP@20
+          v20:BasicObject = GetLocal l0, SP@19
+          v21:BasicObject = GetLocal l0, SP@18
+          v22:BasicObject = GetLocal l0, SP@17
+          v23:BasicObject = GetLocal l0, SP@16
+          v24:BasicObject = GetLocal l0, SP@15
+          v25:BasicObject = GetLocal l0, SP@14
+          v26:BasicObject = GetLocal l0, SP@13
+          v27:BasicObject = GetLocal l0, SP@12
+          v28:BasicObject = GetLocal l0, SP@11
+          v29:BasicObject = GetLocal l0, SP@10
+          v30:BasicObject = GetLocal l0, SP@9
+          v31:BasicObject = GetLocal l0, SP@8
+          v32:BasicObject = GetLocal l0, SP@7
+          v33:BasicObject = GetLocal l0, SP@6
+          v34:BasicObject = GetLocal l0, SP@5
+          v35:BasicObject = GetLocal l0, SP@4
+          Jump bb2(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+        bb1(v38:BasicObject, v39:BasicObject, v40:BasicObject, v41:BasicObject, v42:BasicObject, v43:BasicObject, v44:BasicObject, v45:BasicObject, v46:BasicObject, v47:BasicObject, v48:BasicObject, v49:BasicObject, v50:BasicObject, v51:BasicObject, v52:BasicObject, v53:BasicObject, v54:BasicObject, v55:BasicObject, v56:BasicObject, v57:BasicObject, v58:BasicObject, v59:BasicObject, v60:BasicObject, v61:BasicObject, v62:BasicObject, v63:BasicObject, v64:BasicObject, v65:BasicObject, v66:BasicObject, v67:BasicObject, v68:BasicObject, v69:BasicObject, v70:BasicObject, v71:BasicObject, v72:BasicObject):
+          EntryPoint JIT(0)
+          Jump bb2(v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72)
+        bb2(v74:BasicObject, v75:BasicObject, v76:BasicObject, v77:BasicObject, v78:BasicObject, v79:BasicObject, v80:BasicObject, v81:BasicObject, v82:BasicObject, v83:BasicObject, v84:BasicObject, v85:BasicObject, v86:BasicObject, v87:BasicObject, v88:BasicObject, v89:BasicObject, v90:BasicObject, v91:BasicObject, v92:BasicObject, v93:BasicObject, v94:BasicObject, v95:BasicObject, v96:BasicObject, v97:BasicObject, v98:BasicObject, v99:BasicObject, v100:BasicObject, v101:BasicObject, v102:BasicObject, v103:BasicObject, v104:BasicObject, v105:BasicObject, v106:BasicObject, v107:BasicObject, v108:BasicObject):
+          SideExit TooManyKeywordParameters
+        ");
+    }
+ }
diff --git a/zjit/src/stats.rs b/zjit/src/stats.rs
index e1d7c692ed..6b3f9b5ce8 100644
--- a/zjit/src/stats.rs
+++ b/zjit/src/stats.rs
@@ -159,6 +159,7 @@ make_counters! {
         exit_stackoverflow,
         exit_block_param_proxy_modified,
         exit_block_param_proxy_not_iseq_or_ifunc,
+        exit_too_many_keyword_parameters,
     }
 
     // Send fallback counters that are summed as dynamic_send_count
@@ -395,6 +396,7 @@ pub fn side_exit_counter(reason: crate::hir::SideExitReason) -> Counter {
         StackOverflow                 => exit_stackoverflow,
         BlockParamProxyModified       => exit_block_param_proxy_modified,
         BlockParamProxyNotIseqOrIfunc => exit_block_param_proxy_not_iseq_or_ifunc,
+        TooManyKeywordParameters      => exit_too_many_keyword_parameters,
         PatchPoint(Invariant::BOPRedefined { .. })
                                       => exit_patchpoint_bop_redefined,
         PatchPoint(Invariant::MethodRedefined { .. })