Allow bindings to handle unknown objects in trace_object() (#593)

This PR adds a new method to `ActivePlan` to allow bindings to handle unknown objects encountered in object tracing.

Author: qinsoon

docs/tutorial/code/mygc_semispace/gc_work.rs

@@ -68,7 +68,7 @@ impl<VM:VMBinding> ProcessEdgesWork for MyGCProcessEdges<VM> {
                 worker,
             )
         } else {
-            self.plan.common.trace_object(queue, object)
+            self.plan.common.trace_object(queue, object, worker)
         }
     }
 }

macros/src/plan_trace_object_impl.rs

@@ -48,7 +48,7 @@ pub(crate) fn generate_trace_object<'a>(
         }
     } else {
         quote! {
-            panic!("No more spaces to try")
+            <VM::VMActivePlan as crate::vm::ActivePlan<VM>>::vm_trace_object::<Q>(__mmtk_queue, __mmtk_objref, __mmtk_worker)
         }
     };
 

src/plan/generational/global.rs

@@ -192,7 +192,7 @@ impl<VM: VMBinding> Gen<VM> {
                 worker,
             );
         }
-        self.common.trace_object::<Q>(queue, object)
+        self.common.trace_object::<Q>(queue, object, worker)
     }
 
     /// Trace objects for spaces in generational and common plans for a nursery GC.

src/plan/global.rs

@@ -603,33 +603,35 @@ impl<VM: VMBinding> BasePlan<VM> {
 
     pub fn trace_object<Q: ObjectQueue>(
         &self,
-        _queue: &mut Q,
-        _object: ObjectReference,
+        queue: &mut Q,
+        object: ObjectReference,
+        worker: &mut GCWorker<VM>,
     ) -> ObjectReference {
         #[cfg(feature = "code_space")]
-        if self.code_space.in_space(_object) {
+        if self.code_space.in_space(object) {
             trace!("trace_object: object in code space");
-            return self.code_space.trace_object::<Q>(_queue, _object);
+            return self.code_space.trace_object::<Q>(queue, object);
         }
 
         #[cfg(feature = "code_space")]
-        if self.code_lo_space.in_space(_object) {
+        if self.code_lo_space.in_space(object) {
             trace!("trace_object: object in large code space");
-            return self.code_lo_space.trace_object::<Q>(_queue, _object);
+            return self.code_lo_space.trace_object::<Q>(queue, object);
         }
 
         #[cfg(feature = "ro_space")]
-        if self.ro_space.in_space(_object) {
+        if self.ro_space.in_space(object) {
             trace!("trace_object: object in ro_space space");
-            return self.ro_space.trace_object(_queue, _object);
+            return self.ro_space.trace_object(queue, object);
         }
 
         #[cfg(feature = "vm_space")]
-        if self.vm_space.in_space(_object) {
+        if self.vm_space.in_space(object) {
             trace!("trace_object: object in boot space");
-            return self.vm_space.trace_object(_queue, _object);
+            return self.vm_space.trace_object(queue, object);
         }
-        panic!("No special case for space in trace_object({:?})", _object);
+
+        VM::VMActivePlan::vm_trace_object::<Q>(queue, object, worker)
     }
 
     pub fn prepare(&mut self, _tls: VMWorkerThread, _full_heap: bool) {
@@ -907,6 +909,7 @@ impl<VM: VMBinding> CommonPlan<VM> {
         &self,
         queue: &mut Q,
         object: ObjectReference,
+        worker: &mut GCWorker<VM>,
     ) -> ObjectReference {
         if self.immortal.in_space(object) {
             trace!("trace_object: object in immortal space");
@@ -916,7 +919,7 @@ impl<VM: VMBinding> CommonPlan<VM> {
             trace!("trace_object: object in los");
             return self.los.trace_object(queue, object);
         }
-        self.base.trace_object::<Q>(queue, object)
+        self.base.trace_object::<Q>(queue, object, worker)
     }
 
     pub fn prepare(&mut self, tls: VMWorkerThread, full_heap: bool) {

src/policy/space.rs

@@ -178,13 +178,14 @@ impl SFT for EmptySpaceSFT {
     fn sft_trace_object(
         &self,
         _queue: &mut VectorObjectQueue,
-        _object: ObjectReference,
+        object: ObjectReference,
         _worker: GCWorkerMutRef,
     ) -> ObjectReference {
+        // We do not have the `VM` type parameter here, so we cannot forward the call to the VM.
         panic!(
-            "Call trace_object() on {} (chunk {}), which maps to an empty space",
-            _object,
-            conversions::chunk_align_down(_object.to_address()),
+            "Call trace_object() on {} (chunk {}), which maps to an empty space. SFTProcessEdges does not support the fallback to vm_trace_object().",
+            object,
+            conversions::chunk_align_down(object.to_address()),
         )
     }
 }

src/scheduler/gc_work.rs

@@ -399,6 +399,11 @@ pub trait ProcessEdgesWork:
     const OVERWRITE_REFERENCE: bool = true;
     const SCAN_OBJECTS_IMMEDIATELY: bool = true;
     fn new(edges: Vec<Address>, roots: bool, mmtk: &'static MMTK<Self::VM>) -> Self;
+
+    /// Trace an MMTk object. The implementation should forward this call to the policy-specific
+    /// `trace_object()` methods, depending on which space this object is in.
+    /// If the object is not in any MMTk space, the implementation should forward the call to
+    /// `ActivePlan::vm_trace_object()` to let the binding handle the tracing.
     fn trace_object(&mut self, object: ObjectReference) -> ObjectReference;
 
     #[cfg(feature = "sanity")]

src/vm/active_plan.rs

@@ -1,7 +1,10 @@
 use crate::plan::Mutator;
 use crate::plan::Plan;
+use crate::scheduler::GCWorker;
 use crate::util::opaque_pointer::*;
+use crate::util::ObjectReference;
 use crate::vm::VMBinding;
+use crate::ObjectQueue;
 use std::marker::PhantomData;
 use std::sync::MutexGuard;
 
@@ -68,4 +71,13 @@ pub trait ActivePlan<VM: VMBinding> {
 
     /// Return the total count of mutators.
     fn number_of_mutators() -> usize;
+
+    /// The fallback for object tracing.
+    fn vm_trace_object<Q: ObjectQueue>(
+        _queue: &mut Q,
+        object: ObjectReference,
+        _worker: &mut GCWorker<VM>,
+    ) -> ObjectReference {
+        panic!("MMTk cannot trace object {:?} as it does not belong to any MMTk space. If the object is known to the VM, the binding can override this method and handle its tracing.", object)
+    }
 }