remove unused handle of table0 cache

Author: Robbepop

crates/wasmi/src/engine/executor/handler/utils.rs

@@ -638,13 +638,14 @@ impl_load_entity_for_inst! {
 impl LoadEntity<Table0> for Inst {
     type Entity = TableEntity;
 
+    #[inline]
     fn load(self, _store: &mut StoreInner, _addr: Table0) -> &mut Self::Entity {
         // SAFETY: `addr` addresses an entry of this kind by translation invariant.
-        let Some(entry) = (unsafe { self.as_ptr().get_table0() }) else {
+        let Some(entity) = (unsafe { self.as_ptr().get_table0() }) else {
             unsafe { unreachable_unchecked!("missing table entity for table 0") }
         };
         // SAFETY: warmed at instantiation; the `_store` borrow scopes the reference.
-        unsafe { &mut *entry.entity().as_ptr() }
+        unsafe { &mut *entity.as_ptr() }
     }
 }
 

crates/wasmi/src/instance/cache.rs

@@ -5,6 +5,7 @@ use crate::{
     Handle,
     Memory,
     Table,
+    core::CoreTable,
     instance::handle::{AnyHandle, HasHandleKind},
     memory::DataSegment,
     store::StoreInner,
@@ -23,7 +24,7 @@ use core::{
 ///
 /// This is the type-erased storage type of an instance's `handles` buffer, which mixes all
 /// handle kinds. Access it as a [`HandleAndEntity<T>`] to get at the handle or entity.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct AnyHandleAndEntity {
     /// The cached entity pointer, warmed up at instantiation.
     entity: NonNull<AnyEntity>,
@@ -46,6 +47,41 @@ unsafe impl Send for AnyHandleAndEntity {}
 //         `&AnyHandleAndEntity` across threads cannot by itself race on entity data.
 unsafe impl Sync for AnyHandleAndEntity {}
 
+/// The cached entity pointer of an instance's `(table 0)`.
+///
+/// # Note
+///
+/// Unlike [`HandleAndEntity`] this drops the handle: `(table 0)` is only ever resolved to its
+/// entity, and halving the field keeps the instance header small.
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct Table0Ptr(NonNull<CoreTable>);
+
+// SAFETY: same argument as for `AnyHandleAndEntity`: the pointee is owned by the very
+//         `StoreInner` that (transitively) owns the instance holding this pointer, so it never
+//         crosses a thread boundary on its own, and `StableArena` addresses survive a `Store` move.
+unsafe impl Send for Table0Ptr {}
+
+// SAFETY: no safe method on `&Table0Ptr` reads or writes the pointee — `get` only hands out a
+//         raw `NonNull` copy whose dereference is `unsafe` and the caller's contract against the
+//         owning `Store`.
+unsafe impl Sync for Table0Ptr {}
+
+impl Table0Ptr {
+    /// Creates a new [`Table0Ptr`] from the warmed up `entity` pointer.
+    pub fn new(entity: NonNull<CoreTable>) -> Self {
+        Self(entity)
+    }
+
+    /// Returns the cached entity pointer of `self`.
+    ///
+    /// The returned pointer is only sound to dereference once the cache has been warmed up.
+    #[inline]
+    pub fn get(self) -> NonNull<CoreTable> {
+        self.0
+    }
+}
+
 impl AnyHandleAndEntity {
     /// Creates a new [`AnyHandleAndEntity`] from the given `handle`.
     ///
@@ -92,7 +128,7 @@ impl AnyHandleAndEntity {
 /// This is a view on an entry of an instance's `handles` buffer. Its constructors assert the
 /// handle kind of the entry — and validate it in debug builds — which is why
 /// [`HandleAndEntity::handle`] and [`HandleAndEntity::entity`] are safe and check nothing.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 #[repr(transparent)]
 pub struct HandleAndEntity<T: Handle> {
     /// The type-erased entry.

crates/wasmi/src/instance/entity.rs

@@ -10,6 +10,7 @@ use super::{
     InstanceEntityBuilder,
     InstanceLayout,
     MemoryAddr,
+    Table0Ptr,
     TableAddr,
     ThinPtr,
 };
@@ -21,6 +22,7 @@ use crate::{
     Module,
     Table,
     collections::Map,
+    core::CoreTable,
     memory::DataSegment,
     store::StoreInner,
 };
@@ -74,7 +76,7 @@ struct InstanceEntityHeader {
     state: InstanceState,
     exports: Map<Box<str>, Extern>,
     layout: InstanceLayout,
-    table0: Option<HandleAndEntity<Table>>,
+    table0: Option<Table0Ptr>,
 }
 
 /// The byte offset of the `handles` buffer within an [`InstanceEntity`] allocation.
@@ -307,7 +309,7 @@ impl InstanceEntity {
             let entry = &self.handles[u32::from(addr) as usize];
             // Safety: the `InstanceLayout` only yields addresses of its own group.
             let entry = unsafe { entry.typed_ref::<Table>() };
-            self.header.table0 = Some(entry.clone());
+            self.header.table0 = Some(Table0Ptr::new(entry.entity()));
         }
     }
 
@@ -487,9 +489,9 @@ impl ThinPtr<InstanceEntity> {
         unsafe { self.header() }.layout()
     }
 
-    /// Returns the [`HandleAndEntity`] for `(table 0)` if any.
-    pub unsafe fn get_table0<'a>(self) -> Option<&'a HandleAndEntity<Table>> {
-        unsafe { self.header() }.table0.as_ref()
+    /// Returns the cached entity pointer for `(table 0)` if any.
+    pub unsafe fn get_table0(self) -> Option<NonNull<CoreTable>> {
+        unsafe { self.header() }.table0.map(Table0Ptr::get)
     }
 
     impl_get_entry! {

crates/wasmi/src/instance/mod.rs

@@ -1,5 +1,5 @@
 pub(crate) use self::builder::InstanceEntityBuilder;
-use self::cache::{AnyHandleAndEntity, HandleAndEntity};
+use self::cache::{AnyHandleAndEntity, HandleAndEntity, Table0Ptr};
 pub use self::{
     entity::InstanceEntity,
     exports::{Export, ExportsIter, Extern, ExternType},