Make ObjectReference non-nullable

Author: wks

mmtk/Cargo.lock

@@ -32,9 +32,10 @@ memoffset = "0.9.0"
 # - change branch
 # - change repo name
 # But other changes including adding/removing whitespaces in commented lines may break the CI.
-mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "a058b8c4f3dbfa625823847bb5df8e5c87f44e34" }
+#mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "a058b8c4f3dbfa625823847bb5df8e5c87f44e34" }
 # Uncomment the following to build locally
 # mmtk = { path = "../repos/mmtk-core" }
+mmtk = { path = "../../mmtk-core" }
 
 [build-dependencies]
 built = { version = "0.7.1", features = ["git2"] }

mmtk/Cargo.toml

@@ -516,11 +516,11 @@ pub extern "C" fn add_finalizer(object: ObjectReference) {
 }
 
 #[no_mangle]
-pub extern "C" fn get_finalized_object() -> ObjectReference {
+pub extern "C" fn get_finalized_object() -> Address {
     with_singleton!(|singleton| {
         match memory_manager::get_finalized_object(singleton) {
-            Some(obj) => obj,
-            None => ObjectReference::NULL,
+            Some(obj) => obj.to_raw_address(),
+            None => Address::ZERO,
         }
     })
 }

mmtk/src/api.rs

@@ -127,37 +127,57 @@ impl<const COMPRESSED: bool> OpenJDKEdge<COMPRESSED> {
 
     /// encode an object pointer to its u32 compressed form
     fn compress(o: ObjectReference) -> u32 {
-        if o.is_null() {
-            0u32
-        } else {
-            ((o.to_raw_address() - BASE.load(Ordering::Relaxed)) >> SHIFT.load(Ordering::Relaxed))
-                as u32
-        }
+        ((o.to_raw_address() - BASE.load(Ordering::Relaxed)) >> SHIFT.load(Ordering::Relaxed))
+            as u32
     }
 
     /// decode an object pointer from its u32 compressed form
-    fn decompress(v: u32) -> ObjectReference {
+    fn decompress(v: u32) -> Option<ObjectReference> {
         if v == 0 {
-            ObjectReference::NULL
+            None
+        } else {
+            // Note on `unsafe`: The result cannot be zero, so it is safe to use here.
+            let objref = unsafe {
+                ObjectReference::from_raw_address_unchecked(
+                    BASE.load(Ordering::Relaxed) + ((v as usize) << SHIFT.load(Ordering::Relaxed)),
+                )
+            };
+            Some(objref)
+        }
+    }
+
+    /// Store a null reference in the slot.
+    pub fn store_null(&self) {
+        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
+            if COMPRESSED {
+                if self.is_compressed() {
+                    self.x86_write_unaligned::<u32, true>(0)
+                } else {
+                    self.x86_write_unaligned::<Address, true>(Address::ZERO)
+                }
+            } else {
+                self.x86_write_unaligned::<Address, false>(Address::ZERO)
+            }
         } else {
-            ObjectReference::from_raw_address(
-                BASE.load(Ordering::Relaxed) + ((v as usize) << SHIFT.load(Ordering::Relaxed)),
-            )
+            debug_assert!(!COMPRESSED);
+            unsafe { self.addr.store(0) }
         }
     }
 }
 
 impl<const COMPRESSED: bool> Edge for OpenJDKEdge<COMPRESSED> {
-    fn load(&self) -> ObjectReference {
+    fn load(&self) -> Option<ObjectReference> {
         if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
             if COMPRESSED {
                 if self.is_compressed() {
                     Self::decompress(self.x86_read_unaligned::<u32, true>())
                 } else {
-                    self.x86_read_unaligned::<ObjectReference, true>()
+                    let addr = self.x86_read_unaligned::<Address, true>();
+                    ObjectReference::from_raw_address(addr)
                 }
             } else {
-                self.x86_read_unaligned::<ObjectReference, false>()
+                let addr = self.x86_read_unaligned::<Address, false>();
+                ObjectReference::from_raw_address(addr)
             }
         } else {
             debug_assert!(!COMPRESSED);

mmtk/src/edges.rs

@@ -31,7 +31,8 @@ impl<const COMPRESSED: bool> ObjectModel<OpenJDK<COMPRESSED>> for VMObjectModel<
         // Copy
         let src = from.to_raw_address();
         unsafe { std::ptr::copy_nonoverlapping::<u8>(src.to_ptr(), dst.to_mut_ptr(), bytes) }
-        let to_obj = ObjectReference::from_raw_address(dst);
+        // Note on onsafe: `alloc_copy` never returns 0.
+        let to_obj = unsafe { ObjectReference::from_raw_address_unchecked(dst) };
         copy_context.post_copy(to_obj, bytes, copy);
         to_obj
     }
@@ -56,7 +57,8 @@ impl<const COMPRESSED: bool> ObjectModel<OpenJDK<COMPRESSED>> for VMObjectModel<
     }
 
     fn get_reference_when_copied_to(_from: ObjectReference, to: Address) -> ObjectReference {
-        ObjectReference::from_raw_address(to)
+        debug_assert!(!to.is_zero());
+        unsafe { ObjectReference::from_raw_address_unchecked(to) }
     }
 
     fn get_current_size(object: ObjectReference) -> usize {
@@ -93,7 +95,8 @@ impl<const COMPRESSED: bool> ObjectModel<OpenJDK<COMPRESSED>> for VMObjectModel<
     }
 
     fn address_to_ref(address: Address) -> ObjectReference {
-        ObjectReference::from_raw_address(address)
+        debug_assert!(!address.is_zero());
+        unsafe { ObjectReference::from_raw_address_unchecked(address) }
     }
 
     fn dump_object(object: ObjectReference) {

mmtk/src/object_model.rs

@@ -15,7 +15,7 @@ impl<const COMPRESSED: bool> ReferenceGlue<OpenJDK<COMPRESSED>> for VMReferenceG
         let oop = Oop::from(reff);
         InstanceRefKlass::referent_address::<COMPRESSED>(oop).store(referent);
     }
-    fn get_referent(object: ObjectReference) -> ObjectReference {
+    fn get_referent(object: ObjectReference) -> Option<ObjectReference> {
         let oop = Oop::from(object);
         InstanceRefKlass::referent_address::<COMPRESSED>(oop).load()
     }
@@ -24,4 +24,8 @@ impl<const COMPRESSED: bool> ReferenceGlue<OpenJDK<COMPRESSED>> for VMReferenceG
             ((*UPCALLS).enqueue_references)(references.as_ptr(), references.len());
         }
     }
+    fn clear_referent(new_reference: ObjectReference) {
+        let oop = Oop::from(new_reference);
+        InstanceRefKlass::referent_address::<COMPRESSED>(oop).store_null();
+    }
 }