ZJIT: Support guarding *Exact types

ZJIT already can generate guard type instructions for *Exact types.

For example:

```
def test(strings)
  strings.map do |string|
    string.bytesize
  end
end

test(["foo", "bar"])
```

```
HIR:
fn block in test:
bb0(v0:BasicObject, v1:BasicObject):
  PatchPoint MethodRedefined(String@0x1014be890, bytesize@0x19f1)
  v7:StringExact = GuardType v1, StringExact
  v8:Fixnum = CCall bytesize@0x16fa4cc18, v7
  Return v8

```

But zjit only supported guarding fixnums so this script would panic.

This commit adds support for guarding *Exact types.

Author: st0012

test/ruby/test_zjit.rb

@@ -915,6 +915,51 @@ def test_instruction_order
     end
   end
 
+  def test_module_name_with_guard_passes
+    assert_compiles '"Integer"', %q{
+      def test(mod)
+        mod.name
+      end
+
+      test(String)
+      test(Integer)
+    }, call_threshold: 2
+  end
+
+  def test_string_bytesize_with_guard
+    assert_compiles '5', %q{
+      def test(str)
+        str.bytesize
+      end
+
+      test('hello')
+      test('world')
+    }, call_threshold: 2
+  end
+
+  def test_guard_type_side_exit
+    # This test demonstrates that the guard side exit works correctly
+    # In this case, when we call with a non-Class object, it should fall back to interpreter
+    assert_compiles '["String", "Integer", "Foo"]', %q{
+      class Foo
+        def name
+          "Foo"
+        end
+      end
+
+      def test(mod)
+        mod.name
+      end
+
+      results = []
+      results << test(String)
+      results << test(Integer)
+      results << test(Foo.new)
+
+      results
+    }, call_threshold: 2
+  end
+
   private
 
   # Assert that every method call in `test_script` can be compiled by ZJIT

zjit/src/codegen.rs

@@ -979,6 +979,16 @@ fn gen_guard_type(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, guard
         // Check if opnd is Fixnum
         asm.test(val, Opnd::UImm(RUBY_FIXNUM_FLAG as u64));
         asm.jz(side_exit(jit, state)?);
+    } else if let Some(expected_class) = guard_type.runtime_exact_ruby_class() {
+        // Guard for exact class types (e.g., ClassExact, ArrayExact, StringExact, etc.)
+        asm_comment!(asm, "guard exact class");
+
+        // Get the class of the value
+        let klass = asm.ccall(rb_yarv_class_of as *const u8, vec![val]);
+
+        // Compare with expected class
+        asm.cmp(klass, Opnd::UImm(expected_class.into()));
+        asm.jne(side_exit(jit, state)?);
     } else {
         unimplemented!("unsupported type: {guard_type}");
     }

zjit/src/hir.rs

@@ -6517,4 +6517,44 @@ mod opt_tests {
               Return v5
         "#]]);
     }
+
+    #[test]
+    fn test_guard_class_for_module_name() {
+        eval("
+            def test(mod)
+              mod.name
+            end
+            # Profile with Class objects
+            test(String)
+            test(Integer)
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject, v1:BasicObject):
+              PatchPoint MethodRedefined(Class@0x1000, name@0x1008)
+              v7:ClassExact = GuardType v1, ClassExact
+              v8:StringExact|NilClassExact = CCall name@0x1010, v7
+              Return v8
+        "#]]);
+    }
+
+    #[test]
+    fn test_guard_string_for_bytesize() {
+        eval("
+            def test(str)
+              str.bytesize
+            end
+            # Profile with String objects
+            test('hello')
+            test('world')
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject, v1:BasicObject):
+              PatchPoint MethodRedefined(String@0x1000, bytesize@0x1008)
+              v7:StringExact = GuardType v1, StringExact
+              v8:Fixnum = CCall bytesize@0x1010, v7
+              Return v8
+        "#]]);
+    }
 }