ZJIT: Add Ruby class objects to HIR type lattice automatically (ruby#14647)

This:

* gets us out of the business of manually writing a bunch of `if`s
* gets us more type information
* cleans up the code
* also adds `types::Numeric`

Author: tekknolagi

zjit/src/hir.rs

@@ -829,7 +829,10 @@ impl<'a> std::fmt::Display for InsnPrinter<'a> {
             Insn::ArrayDup { val, .. } => { write!(f, "ArrayDup {val}") }
             Insn::HashDup { val, .. } => { write!(f, "HashDup {val}") }
             Insn::ObjectAlloc { val, .. } => { write!(f, "ObjectAlloc {val}") }
-            Insn::ObjectAllocClass { class, .. } => { write!(f, "ObjectAllocClass {}", class.print(self.ptr_map)) }
+            &Insn::ObjectAllocClass { class, .. } => {
+                let class_name = get_class_name(class);
+                write!(f, "ObjectAllocClass {class_name}:{}", class.print(self.ptr_map))
+            }
             Insn::StringCopy { val, .. } => { write!(f, "StringCopy {val}") }
             Insn::StringConcat { strings, .. } => {
                 write!(f, "StringConcat")?;
@@ -5637,7 +5640,7 @@ mod tests {
           v10:ArrayExact = ToArray v2
           PatchPoint NoEPEscape(test)
           GuardBlockParamProxy l0
-          v15:BasicObject[BlockParamProxy] = Const Value(VALUE(0x1000))
+          v15:HeapObject[BlockParamProxy] = Const Value(VALUE(0x1000))
           SideExit UnhandledYARVInsn(splatkw)
         ");
     }
@@ -6221,16 +6224,16 @@ mod tests {
           v10:BasicObject = InvokeBuiltin dir_s_open, v0, v1, v2
           PatchPoint NoEPEscape(open)
           GuardBlockParamProxy l0
-          v17:BasicObject[BlockParamProxy] = Const Value(VALUE(0x1000))
+          v17:HeapObject[BlockParamProxy] = Const Value(VALUE(0x1000))
           CheckInterrupts
-          v20:CBool = Test v17
+          v20:CBool[true] = Test v17
           IfFalse v20, bb1(v0, v1, v2, v3, v4, v10)
           PatchPoint NoEPEscape(open)
           v27:BasicObject = InvokeBlock, v10
           v31:BasicObject = InvokeBuiltin dir_s_close, v0, v10
           CheckInterrupts
           Return v27
-        bb1(v37:BasicObject, v38:BasicObject, v39:BasicObject, v40:BasicObject, v41:BasicObject, v42:BasicObject):
+        bb1(v37, v38, v39, v40, v41, v42):
           PatchPoint NoEPEscape(open)
           CheckInterrupts
           Return v42
@@ -8033,7 +8036,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           PatchPoint SingleRactorMode
           PatchPoint StableConstantNames(0x1000, MY_MODULE)
-          v13:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+          v13:HeapObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           CheckInterrupts
           Return v13
         ");
@@ -8378,7 +8381,7 @@ mod opt_tests {
           v34:Class[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           v6:NilClass = Const Value(nil)
           PatchPoint MethodRedefined(C@0x1008, new@0x1010, cme:0x1018)
-          v37:HeapObject[class_exact:C] = ObjectAllocClass VALUE(0x1008)
+          v37:HeapObject[class_exact:C] = ObjectAllocClass C:VALUE(0x1008)
           PatchPoint MethodRedefined(C@0x1008, initialize@0x1040, cme:0x1048)
           v39:NilClass = CCall initialize@0x1070, v37
           CheckInterrupts
@@ -8407,7 +8410,7 @@ mod opt_tests {
           v6:NilClass = Const Value(nil)
           v7:Fixnum[1] = Const Value(1)
           PatchPoint MethodRedefined(C@0x1008, new@0x1010, cme:0x1018)
-          v39:HeapObject[class_exact:C] = ObjectAllocClass VALUE(0x1008)
+          v39:HeapObject[class_exact:C] = ObjectAllocClass C:VALUE(0x1008)
           PatchPoint MethodRedefined(C@0x1008, initialize@0x1040, cme:0x1048)
           v41:BasicObject = SendWithoutBlockDirect v39, :initialize (0x1070), v7
           CheckInterrupts
@@ -8430,7 +8433,7 @@ mod opt_tests {
           v34:Class[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           v6:NilClass = Const Value(nil)
           PatchPoint MethodRedefined(Object@0x1008, new@0x1010, cme:0x1018)
-          v37:HeapObject[class_exact:Object] = ObjectAllocClass VALUE(0x1008)
+          v37:ObjectExact = ObjectAllocClass Object:VALUE(0x1008)
           PatchPoint MethodRedefined(Object@0x1008, initialize@0x1040, cme:0x1048)
           v39:NilClass = CCall initialize@0x1070, v37
           CheckInterrupts
@@ -8453,7 +8456,7 @@ mod opt_tests {
           v34:Class[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           v6:NilClass = Const Value(nil)
           PatchPoint MethodRedefined(BasicObject@0x1008, new@0x1010, cme:0x1018)
-          v37:HeapObject[class_exact:BasicObject] = ObjectAllocClass VALUE(0x1008)
+          v37:BasicObjectExact = ObjectAllocClass BasicObject:VALUE(0x1008)
           PatchPoint MethodRedefined(BasicObject@0x1008, initialize@0x1040, cme:0x1048)
           v39:NilClass = CCall initialize@0x1070, v37
           CheckInterrupts
@@ -8476,7 +8479,7 @@ mod opt_tests {
           v34:Class[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           v6:NilClass = Const Value(nil)
           PatchPoint MethodRedefined(Hash@0x1008, new@0x1010, cme:0x1018)
-          v37:HashExact = ObjectAllocClass VALUE(0x1008)
+          v37:HashExact = ObjectAllocClass Hash:VALUE(0x1008)
           v12:BasicObject = SendWithoutBlock v37, :initialize
           CheckInterrupts
           CheckInterrupts
@@ -8523,7 +8526,7 @@ mod opt_tests {
           PatchPoint MethodRedefined(Set@0x1008, new@0x1010, cme:0x1018)
           v10:HeapObject = ObjectAlloc v34
           PatchPoint MethodRedefined(Set@0x1008, initialize@0x1040, cme:0x1048)
-          v39:HeapObject[class_exact:Set] = GuardType v10, HeapObject[class_exact:Set]
+          v39:SetExact = GuardType v10, SetExact
           v40:BasicObject = CCallVariadic initialize@0x1070, v39
           CheckInterrupts
           CheckInterrupts
@@ -8568,7 +8571,7 @@ mod opt_tests {
           v7:StringExact[VALUE(0x1010)] = Const Value(VALUE(0x1010))
           v9:StringExact = StringCopy v7
           PatchPoint MethodRedefined(Regexp@0x1008, new@0x1018, cme:0x1020)
-          v41:HeapObject[class_exact:Regexp] = ObjectAllocClass VALUE(0x1008)
+          v41:RegexpExact = ObjectAllocClass Regexp:VALUE(0x1008)
           PatchPoint MethodRedefined(Regexp@0x1008, initialize@0x1048, cme:0x1050)
           v44:BasicObject = CCallVariadic initialize@0x1078, v41, v9
           CheckInterrupts
@@ -8618,7 +8621,7 @@ mod opt_tests {
         fn test@<compiled>:2:
         bb0(v0:BasicObject, v1:BasicObject):
           GuardBlockParamProxy l0
-          v7:BasicObject[BlockParamProxy] = Const Value(VALUE(0x1000))
+          v7:HeapObject[BlockParamProxy] = Const Value(VALUE(0x1000))
           v9:BasicObject = Send v0, 0x1008, :tap, v7
           CheckInterrupts
           Return v9
@@ -9632,10 +9635,9 @@ mod opt_tests {
         bb0(v0:BasicObject):
           PatchPoint SingleRactorMode
           PatchPoint StableConstantNames(0x1000, O)
-          v15:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+          v15:HeapObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           PatchPoint MethodRedefined(C@0x1010, foo@0x1018, cme:0x1020)
-          v18:HeapObject[VALUE(0x1008)] = GuardType v15, HeapObject
-          v19:HeapObject[VALUE(0x1008)] = GuardShape v18, 0x1048
+          v19:HeapObject[VALUE(0x1008)] = GuardShape v15, 0x1048
           v20:NilClass = Const Value(nil)
           CheckInterrupts
           Return v20
@@ -9659,10 +9661,9 @@ mod opt_tests {
         bb0(v0:BasicObject):
           PatchPoint SingleRactorMode
           PatchPoint StableConstantNames(0x1000, O)
-          v15:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+          v15:HeapObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
           PatchPoint MethodRedefined(C@0x1010, foo@0x1018, cme:0x1020)
-          v18:HeapObject[VALUE(0x1008)] = GuardType v15, HeapObject
-          v19:HeapObject[VALUE(0x1008)] = GuardShape v18, 0x1048
+          v19:HeapObject[VALUE(0x1008)] = GuardShape v15, 0x1048
           v20:NilClass = Const Value(nil)
           CheckInterrupts
           Return v20

zjit/src/hir_type/gen_hir_type.rb

@@ -58,50 +58,65 @@ def to_graphviz type
 $subclass = [basic_object_subclass.name, object_subclass.name]
 $builtin_exact = [basic_object_exact.name, object_exact.name]
 
+$c_names = {
+  "ObjectExact" => "rb_cObject",
+  "BasicObjectExact" => "rb_cBasicObject",
+}
+
 # Define a new type that can be subclassed (most of them).
-def base_type name
+# If c_name is given, mark the rb_cXYZ object as equivalent to this exact type.
+def base_type name, c_name: nil
   type = $object.subtype name
   exact = type.subtype(name+"Exact")
+  if c_name
+    $c_names[exact.name] = c_name
+  end
   subclass = type.subtype(name+"Subclass")
   $builtin_exact << exact.name
   $subclass << subclass.name
   [type, exact]
 end
 
 # Define a new type that cannot be subclassed.
-def final_type name
-  type = $object.subtype name
+# If c_name is given, mark the rb_cXYZ object as equivalent to this type.
+def final_type name, base: $object, c_name: nil
+  if c_name
+    $c_names[name] = c_name
+  end
+  type = base.subtype name
   $builtin_exact << type.name
   type
 end
 
-base_type "String"
-base_type "Array"
-base_type "Hash"
-base_type "Range"
-base_type "Set"
-base_type "Regexp"
-module_class, _ = base_type "Module"
-module_class.subtype "Class"
+base_type "String", c_name: "rb_cString"
+base_type "Array", c_name: "rb_cArray"
+base_type "Hash", c_name: "rb_cHash"
+base_type "Range", c_name: "rb_cRange"
+base_type "Set", c_name: "rb_cSet"
+base_type "Regexp", c_name: "rb_cRegexp"
+module_class, _ = base_type "Module", c_name: "rb_cModule"
+class_ = final_type "Class", base: module_class, c_name: "rb_cClass"
+
+numeric, _ = base_type "Numeric", c_name: "rb_cNumeric"
 
-integer_exact = final_type "Integer"
+integer_exact = final_type "Integer", base: numeric, c_name: "rb_cInteger"
 # CRuby partitions Integer into immediate and non-immediate variants.
 fixnum = integer_exact.subtype "Fixnum"
 integer_exact.subtype "Bignum"
 
-float_exact = final_type "Float"
+float_exact = final_type "Float", base: numeric, c_name: "rb_cFloat"
 # CRuby partitions Float into immediate and non-immediate variants.
 flonum = float_exact.subtype "Flonum"
 float_exact.subtype "HeapFloat"
 
-symbol_exact = final_type "Symbol"
+symbol_exact = final_type "Symbol", c_name: "rb_cSymbol"
 # CRuby partitions Symbol into immediate and non-immediate variants.
 static_sym = symbol_exact.subtype "StaticSymbol"
 symbol_exact.subtype "DynamicSymbol"
 
-nil_exact = final_type "NilClass"
-true_exact = final_type "TrueClass"
-false_exact = final_type "FalseClass"
+nil_exact = final_type "NilClass", c_name: "rb_cNilClass"
+true_exact = final_type "TrueClass", c_name: "rb_cTrueClass"
+false_exact = final_type "FalseClass", c_name: "rb_cFalseClass"
 
 # Build the cvalue object universe. This is for C-level types that may be
 # passed around when calling into the Ruby VM or after some strength reduction
@@ -183,4 +198,9 @@ def add_union name, type_names
 $bits.keys.sort.map {|type_name|
     puts "  pub const #{type_name}: Type = Type::from_bits(bits::#{type_name});"
 }
+puts "  pub const ExactBitsAndClass: [(u64, *const VALUE); #{$c_names.size}] = ["
+$c_names.each {|type_name, c_name|
+  puts "    (bits::#{type_name}, &raw const crate::cruby::#{c_name}),"
+}
+puts "  ];"
 puts "}"