More object format work, before I finally remove it

Author: Techcable

libs/context/src/collector.rs

@@ -13,16 +13,16 @@ use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutab
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
 use std::ffi::c_void;
+use zerogc::format::{ObjectFormat, GcLayoutInternals};
 
 /// A specific implementation of a collector
-pub unsafe trait RawCollectorImpl: 'static + Sized {
-    /// A dynamic pointer to a GC object
+pub unsafe trait RawCollectorImpl: GcLayoutInternals + 'static + Sized {
+    /// A dynamic pointer to a `Trace` root
     ///
     /// The simple collector implements this as
     /// a trait object pointer.
-    type GcDynPointer: Copy + Debug + 'static;
-
-    unsafe fn dyn_ptr_from_raw(raw: *mut c_void) -> Self::GcDynPointer;
+    type DynTracePtr: Copy + Debug + 'static;
+    type Fmt: ObjectFormat<Self>;
 
     /// A pointer to this collector
     ///
@@ -48,7 +48,7 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
         where 'gc: 'a, T: GcSafe + ?Sized + 'gc;
 
     /// Convert the specified value into a dyn pointer
-    unsafe fn create_dyn_pointer<T: GcSafe>(&self, t: *mut T) -> Self::GcDynPointer;
+    unsafe fn create_dyn_pointer<T: Trace>(&self, t: *mut T) -> Self::DynTracePtr;
 
     /// Initialize an instance of the collector
     ///

libs/context/src/handle.rs

@@ -13,6 +13,7 @@ use crate::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, C
 use crate::collector::RawCollectorImpl;
 use std::ffi::c_void;
 use crate::utils::AtomicCell;
+use zerogc::format::ObjectFormat;
 
 const INITIAL_HANDLE_CAPACITY: usize = 64;
 
@@ -234,7 +235,7 @@ impl<C: RawHandleImpl> GcHandleList<C> {
     /// Now that's behind a layer of abstraction,
     /// the unsafety has technically been moved to the caller.
     pub unsafe fn trace<F, E>(&mut self, mut visitor: F) -> Result<(), E>
-        where F: FnMut(C::GcDynPointer, &C::TypeInfo) -> Result<(), E> {
+        where F: FnMut(<C::Fmt as ObjectFormat<C>>::DynObject, &C::TypeInfo) -> Result<(), E> {
         /*
          * TODO: This fence seems unnecessary since we should
          * already have exclusive access.....
@@ -380,11 +381,11 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
     /// - It is assumed that the appropriate atomic fences (if any)
     ///   have already been applied (TODO: Don't we have exclusive access?)
     unsafe fn trace_inner<F, E>(&self, trace: &mut F) -> Result<(), E>
-        where F: FnMut(C::GcDynPointer, &C::TypeInfo) -> Result<(), E> {
+        where F: FnMut(<C::Fmt as ObjectFormat<C>>::DynObject, &C::TypeInfo) -> Result<(), E> {
         let raw_value = self.value.load(Ordering::Relaxed);
         assert_eq!(
             std::mem::size_of::<*mut ()>(),
-            std::mem::size_of::<C::GcDynPointer>(),
+            std::mem::size_of::<C::DynTracePtr>(),
         );
         if raw_value.is_null() {
             debug_assert_eq!(
@@ -397,7 +398,7 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
             self.refcnt.load(Ordering::Relaxed),
             0
         );
-        let value = C::dyn_ptr_from_raw(raw_value as *mut c_void);
+        let value = C::Fmt::untyped_object_from_raw(raw_value as *mut c_void);
         let type_info = self.type_info.load();
         trace(value, &type_info)
     }

libs/context/src/lib.rs

@@ -241,16 +241,16 @@ impl<C: RawCollectorImpl> Debug for ShadowStack<C> {
 pub struct ShadowStack<C: RawCollectorImpl> {
     /// The last element in the shadow stack,
     /// or NULL if it's empty
-    pub(crate) last: *const ShadowStackLink<C::GcDynPointer>
+    pub(crate) last: *const ShadowStackLink<C::DynTracePtr>
 }
 impl<C: RawCollectorImpl> ShadowStack<C> {
-    unsafe fn as_vec(&self) -> Vec<C::GcDynPointer> {
+    unsafe fn as_vec(&self) -> Vec<C::DynTracePtr> {
         let mut result: Vec<_> = self.reverse_iter().collect();
         result.reverse();
         result
     }
     #[inline]
-    pub unsafe fn reverse_iter(&self) -> impl Iterator<Item=C::GcDynPointer> + '_ {
+    pub unsafe fn reverse_iter(&self) -> impl Iterator<Item=C::DynTracePtr> + '_ {
         core::iter::successors(
             self.last.as_ref(),
             |link| link.prev.as_ref()

libs/simple/src/layout.rs

@@ -1,4 +1,4 @@
-use std::mem::ManuallyDrop;
+use std::mem::{ManuallyDrop, MaybeUninit};
 use std::ffi::c_void;
 use std::alloc::Layout;
 use std::mem;
@@ -69,23 +69,23 @@ impl<Fmt: RawObjectFormat> SimpleMarkData<Fmt> {
 pub struct SimpleMarkDataSnapshot<Fmt: RawObjectFormat> {
     pub state: RawMarkState,
     #[cfg(feature = "multiple-collectors")]
-    pub collector_id: CollectorId<Fmt>
+    pub collector_id_ptr: *mut CollectorId<Fmt>
 }
 impl<Fmt: RawObjectFormat> SimpleMarkDataSnapshot<Fmt> {
-    pub fn new(state: RawMarkState, collector_id: CollectorId<Fmt>) -> Self {
+    pub fn new(state: RawMarkState, collector_id_ptr: *mut CollectorId<Fmt>) -> Self {
         #[cfg(feature = "multiple-collectors")] {
-            SimpleMarkDataSnapshot { state, collector_id }
+            SimpleMarkDataSnapshot { state, collector_id_ptr }
         }
         #[cfg(not(feature = "multiple-collectors"))] {
-            drop(collector_id); // avoid warnings
+            drop(collector_id_ptr); // avoid warnings
             SimpleMarkDataSnapshot { state }
         }
     }
     #[inline]
     fn packed(&self) -> usize {
         let base: usize;
         #[cfg(feature = "multiple-collectors")] {
-            base = self.collector_id.as_ref() as *const RawSimpleCollector<Fmt> as usize;
+            base = (*self.collector_id_ptr).as_ref() as *const RawSimpleCollector<Fmt> as usize;
         }
         #[cfg(not(feature = "multiple-collectors"))] {
             base = 0;
@@ -98,8 +98,8 @@ impl<Fmt: RawObjectFormat> SimpleMarkDataSnapshot<Fmt> {
         let state = MarkState::from_byte((packed & STATE_MASK) as u8);
         let id_bytes: usize = packed & !STATE_MASK;
         #[cfg(feature="multiple-collectors")] {
-            let collector_id = CollectorId::from_raw(NonNull::new_unchecked(id_bytes));
-            SimpleMarkDataSnapshot { state, collector_id }
+            let collector_id_ptr = id_bytes as *mut CollectorId<Fmt>;
+            SimpleMarkDataSnapshot { state, collector_id_ptr }
         }
         #[cfg(not(feature = "multiple-collectors"))] {
             SimpleMarkDataSnapshot { state }
@@ -112,7 +112,7 @@ struct DynamicObj;
 
 #[repr(C)]
 pub(crate) struct BigGcObject<Fmt: RawObjectFormat, T = DynamicObj> {
-    pub(crate) header: Fmt::SizedHeaderType,
+    pub(crate) header: MaybeUninit<Fmt::SizedHeaderType>,
     /// This is dropped using dynamic type info
     pub(crate) static_value: ManuallyDrop<T>
 }