Rename KlassID to KlassKind

This follows the upstream change

Author: wks

mmtk/src/abi.rs

@@ -25,15 +25,15 @@ pub const BITS_IN_LONG: usize = 1 << LOG_BITS_IN_LONG;
 #[repr(i32)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 #[allow(dead_code)]
-pub enum KlassID {
+pub enum KlassKind {
     Instance,
     InstanceRef,
     InstanceMirror,
     InstanceClassLoader,
     InstanceStackChunk,
     TypeArray,
     ObjArray,
-    MaxKlassID
+    Unknown,
 }
 
 #[repr(i32)]
@@ -66,7 +66,7 @@ pub struct Klass {
     #[cfg(debug_assertions)]
     valid: i32,
     pub layout_helper: i32,
-    pub id: KlassID, // _kind
+    pub kind: KlassKind,
     pub modifier_flags: i32,
     pub super_check_offset: u32,
     pub name: OpaquePointer, // Symbol*
@@ -82,7 +82,7 @@ pub struct Klass {
     pub vtable_len: i32,
     pub access_flags: i32, // AccessFlags
     #[cfg(feature = "jfr")]
-    pub trace_id: u64,     // JFR_ONLY(traceid _trace_id;)
+    pub trace_id: u64, // JFR_ONLY(traceid _trace_id;)
     pub shared_class_flags: u16,
     pub archived_mirror_index: i32,
     pub padding: i32,
@@ -137,7 +137,7 @@ pub struct InstanceKlass {
     pub init_state: u8,
     pub reference_type: ReferenceType,
     pub misc_flags: u16,
-    pub init_monitor: OpaquePointer,         // Monitor*
+    pub init_monitor: OpaquePointer,        // Monitor*
     pub init_thread: OpaquePointer,         // Thread*
     pub oop_map_cache: OpaquePointer,       // OopMapCache*
     pub jni_ids: OpaquePointer,             // JNIid*

mmtk/src/object_model.rs

@@ -1,4 +1,4 @@
-use crate::abi::Oop;
+use crate::abi::{KlassKind, Oop};
 use crate::UPCALLS;
 use crate::{vm_metadata, OpenJDK};
 use mmtk::util::alloc::fill_alignment_gap;
@@ -99,9 +99,8 @@ impl<const COMPRESSED: bool> ObjectModel<OpenJDK<COMPRESSED>> for VMObjectModel<
 
     fn is_object_sane(object: ObjectReference) -> bool {
         let oop = Oop::from(object);
-        // It is only valid if klass.id is between 0 and 5 (see KlassID in openjdk/src/hotspot/share/oops/klass.hpp)
-        // If oop.klass is not a valid pointer, we may segfault here.
-        let klass_id = oop.klass::<COMPRESSED>().id as i32;
-        (0..6).contains(&klass_id)
+        // The KlassKind must be one of the known variants, and cannot be InstanceStackChunk which we don't support.
+        let kind = oop.klass::<COMPRESSED>().kind;
+        (kind as i32) < (KlassKind::Unknown as i32) && kind != KlassKind::InstanceStackChunk
     }
 }

mmtk/src/object_scanning.rs

@@ -181,42 +181,42 @@ fn oop_iterate_slow<const COMPRESSED: bool, V: SlotVisitor<S<COMPRESSED>>>(
 
 fn oop_iterate<const COMPRESSED: bool>(oop: Oop, closure: &mut impl SlotVisitor<S<COMPRESSED>>) {
     let klass = oop.klass::<COMPRESSED>();
-    let klass_id = klass.id;
+    let klass_id = klass.kind;
     assert!(
-        klass_id as i32 >= 0 && (klass_id as i32) < KlassID::MaxKlassID as i32,
+        klass_id as i32 >= 0 && (klass_id as i32) < KlassKind::Unknown as i32,
         "Invalid klass-id: {:x} for oop: {:x}",
         klass_id as i32,
         unsafe { mem::transmute::<Oop, ObjectReference>(oop) }
     );
     match klass_id {
-        KlassID::Instance => {
+        KlassKind::Instance => {
             let instance_klass = unsafe { klass.cast::<InstanceKlass>() };
             instance_klass.oop_iterate::<COMPRESSED>(oop, closure);
         }
-        KlassID::InstanceClassLoader => {
+        KlassKind::InstanceClassLoader => {
             let instance_klass = unsafe { klass.cast::<InstanceClassLoaderKlass>() };
             instance_klass.oop_iterate::<COMPRESSED>(oop, closure);
         }
-        KlassID::InstanceMirror => {
+        KlassKind::InstanceMirror => {
             let instance_klass = unsafe { klass.cast::<InstanceMirrorKlass>() };
             instance_klass.oop_iterate::<COMPRESSED>(oop, closure);
         }
-        KlassID::ObjArray => {
+        KlassKind::ObjArray => {
             let array_klass = unsafe { klass.cast::<ObjArrayKlass>() };
             array_klass.oop_iterate::<COMPRESSED>(oop, closure);
         }
-        KlassID::TypeArray => {
+        KlassKind::TypeArray => {
             // Skip scanning primitive arrays as they contain no reference fields.
         }
-        KlassID::InstanceRef => {
+        KlassKind::InstanceRef => {
             let instance_klass = unsafe { klass.cast::<InstanceRefKlass>() };
             instance_klass.oop_iterate::<COMPRESSED>(oop, closure);
         }
-        KlassID::InstanceStackChunk => {
+        KlassKind::InstanceStackChunk => {
             unreachable!("StackChunkOop not supported!")
         }
-        KlassID::MaxKlassID => {
-            unreachable!("Invalid KlassID")
+        KlassKind::Unknown => {
+            unreachable!("Unknown KlassKind")
         }
     }
 }