ZJIT: Profiling: Separate bits for T_CLASS and T_MODULE

So I don't need to use is_subclass_of(). We already have two branches
for the two types during profiling anyways.

Author: XrXr

zjit/src/hir.rs

@@ -4422,10 +4422,10 @@ impl Function {
 
     /// This puts a guard that establishes the preconditon for [Self::load_ivar]
     fn load_ivar_guard_type(&mut self, block: BlockId, recv: InsnId, recv_type: ProfiledType, state: InsnId) -> InsnId {
-        if recv_type.class().is_subclass_of(unsafe { rb_cClass }) == ClassRelationship::Subclass {
+        if recv_type.flags().is_t_class() {
             // Check class first since `Class < Module`
             self.push_insn(block, Insn::GuardType { val: recv, guard_type: types::Class, state })
-        } else if recv_type.class().is_subclass_of(unsafe { rb_cModule }) == ClassRelationship::Subclass {
+        } else if recv_type.flags().is_t_module() {
             self.push_insn(block, Insn::GuardType { val: recv, guard_type: types::Module, state })
         } else if recv_type.flags().is_typed_data() {
             self.push_insn(block, Insn::GuardType { val: recv, guard_type: types::TypedTData, state })
@@ -4448,7 +4448,7 @@ impl Function {
             // shape + iv name
             return self.push_insn(block, Insn::Const { val: Const::Value(Qnil) });
         }
-        if recv_type.flags().is_t_class_or_module() {
+        if recv_type.flags().is_t_class() || recv_type.flags().is_t_module() {
             // Class/module ivar: load from prime classext's fields_obj
             if !self.assume_root_box(block, state) {
                 // Non-root box active: fall back to C call

zjit/src/profile.rs

@@ -206,10 +206,12 @@ impl Flags {
     const IS_OBJECT_PROFILING: u32 = 1 << 4;
     /// Class/module fields_obj is embedded (or absent)
     const IS_FIELDS_EMBEDDED: u32 = 1 << 5;
-    /// Object is a T_CLASS or T_MODULE
-    const IS_T_CLASS_OR_MODULE: u32 = 1 << 6;
+    /// Object is a T_CLASS
+    const IS_T_CLASS: u32 = 1 << 6;
+    /// Object is a T_MODULE
+    const IS_T_MODULE: u32 = 1 << 7;
     /// Object is a typed T_DATA (RTYPEDDATA_P)
-    const IS_TYPED_DATA: u32 = 1 << 7;
+    const IS_TYPED_DATA: u32 = 1 << 8;
 
     pub fn none() -> Self { Self(Self::NONE) }
 
@@ -220,7 +222,8 @@ impl Flags {
     pub fn is_struct_embedded(self) -> bool { (self.0 & Self::IS_STRUCT_EMBEDDED) != 0 }
     pub fn is_object_profiling(self) -> bool { (self.0 & Self::IS_OBJECT_PROFILING) != 0 }
     pub fn is_fields_embedded(self) -> bool { (self.0 & Self::IS_FIELDS_EMBEDDED) != 0 }
-    pub fn is_t_class_or_module(self) -> bool { (self.0 & Self::IS_T_CLASS_OR_MODULE) != 0 }
+    pub fn is_t_class(self) -> bool { (self.0 & Self::IS_T_CLASS) != 0 }
+    pub fn is_t_module(self) -> bool { (self.0 & Self::IS_T_MODULE) != 0 }
     pub fn is_typed_data(self) -> bool { (self.0 & Self::IS_TYPED_DATA) != 0 }
 }
 
@@ -298,8 +301,14 @@ impl ProfiledType {
         if unsafe { RB_TYPE_P(obj, RUBY_T_OBJECT) } {
             flags.0 |= Flags::IS_T_OBJECT;
         }
-        if unsafe { RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE) } {
-            flags.0 |= Flags::IS_T_CLASS_OR_MODULE;
+        if unsafe { RB_TYPE_P(obj, RUBY_T_CLASS) } {
+            flags.0 |= Flags::IS_T_CLASS;
+            if obj.class_fields_embedded_p() {
+                flags.0 |= Flags::IS_FIELDS_EMBEDDED;
+            }
+        }
+        if unsafe { RB_TYPE_P(obj, RUBY_T_MODULE) } {
+            flags.0 |= Flags::IS_T_MODULE;
             if obj.class_fields_embedded_p() {
                 flags.0 |= Flags::IS_FIELDS_EMBEDDED;
             }
@@ -333,16 +342,19 @@ impl ProfiledType {
         self.flags
     }
 
-    /// For ivar access
+    /// For ivar access, you need to know the index in the fields array (described by the shape)
+    /// and the way to get the fields array (described by the builtin type). Both pieces of
+    /// information are on the `RBasic::flags` field. This method returns expected masked flags
+    /// for guarding.
     pub fn rbasic_flags_and_mask(&self) -> (u64, u64) {
         let shape_flag_shift = u64::from(RB_SHAPE_FLAG_SHIFT);
         let (shape, shape_mask) = (u64::from(self.shape().0) << shape_flag_shift, !0 << shape_flag_shift);
         let (builtin_type, type_mask) = if self.flags().is_t_object() {
             (RUBY_T_OBJECT, RUBY_T_MASK)
-        } else if self.class().is_subclass_of(unsafe { rb_cClass }) == ClassRelationship::Subclass {
+        } else if self.flags().is_t_class() {
             // Check class first since `Class < Module`
             (RUBY_T_CLASS, RUBY_T_MASK)
-        } else if self.class().is_subclass_of(unsafe { rb_cModule }) == ClassRelationship::Subclass {
+        } else if self.flags().is_t_module() {
             (RUBY_T_MODULE, RUBY_T_MASK)
         } else if self.flags().is_typed_data() {
             (RUBY_T_DATA | RUBY_TYPED_FL_IS_TYPED_DATA, RUBY_T_MASK | RUBY_TYPED_FL_IS_TYPED_DATA)