wasmtime/runtime/vm/gc/enabled/

arrayref.rs

use crate::{
    StorageType, Val, bail_bug,
    prelude::*,
    runtime::vm::{GcHeap, GcStore, VMGcRef},
    store::{AutoAssertNoGc, StoreOpaque},
};
use core::fmt;
use wasmtime_environ::{GcArrayLayout, VMGcKind};

/// A `VMGcRef` that we know points to a `array`.
///
/// Create a `VMArrayRef` via `VMGcRef::into_arrayref` and
/// `VMGcRef::as_arrayref`, or their untyped equivalents
/// `VMGcRef::into_arrayref_unchecked` and `VMGcRef::as_arrayref_unchecked`.
///
/// Note: This is not a `TypedGcRef<_>` because each collector can have a
/// different concrete representation of `arrayref` that they allocate inside
/// their heaps.
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct VMArrayRef(VMGcRef);

impl fmt::Pointer for VMArrayRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Pointer::fmt(&self.0, f)
    }
}

impl From<VMArrayRef> for VMGcRef {
    #[inline]
    fn from(x: VMArrayRef) -> Self {
        x.0
    }
}

impl VMGcRef {
    /// Is this `VMGcRef` pointing to a `array`?
    pub fn is_arrayref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> bool {
        if self.is_i31() {
            return false;
        }

        match gc_heap.header(&self) {
            Ok(header) => header.matches_kind(VMGcKind::ArrayRef),
            Err(_) => false,
        }
    }

    /// Create a new `VMArrayRef` from the given `gc_ref`.
    ///
    /// If this is not a GC reference to an `arrayref`, `Err(self)` is
    /// returned.
    pub fn into_arrayref(self, gc_heap: &(impl GcHeap + ?Sized)) -> Result<VMArrayRef, VMGcRef> {
        if self.is_arrayref(gc_heap) {
            Ok(self.into_arrayref_unchecked())
        } else {
            Err(self)
        }
    }

    /// Create a new `VMArrayRef` from `self` without actually checking that
    /// `self` is an `arrayref`.
    ///
    /// This method does not check that `self` is actually an `arrayref`, but
    /// it should be. Failure to uphold this invariant is memory safe but will
    /// result in general incorrectness down the line such as panics or wrong
    /// results.
    #[inline]
    pub fn into_arrayref_unchecked(self) -> VMArrayRef {
        debug_assert!(!self.is_i31());
        VMArrayRef(self)
    }

    /// Get this GC reference as an `arrayref` reference, if it actually is an
    /// `arrayref` reference.
    pub fn as_arrayref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> Option<&VMArrayRef> {
        if self.is_arrayref(gc_heap) {
            Some(self.as_arrayref_unchecked())
        } else {
            None
        }
    }

    /// Get this GC reference as an `arrayref` reference without checking if it
    /// actually is an `arrayref` reference.
    ///
    /// Calling this method on a non-`arrayref` reference is memory safe, but
    /// will lead to general incorrectness like panics and wrong results.
    pub fn as_arrayref_unchecked(&self) -> &VMArrayRef {
        debug_assert!(!self.is_i31());
        let ptr = self as *const VMGcRef;
        let ret = unsafe { &*ptr.cast() };
        assert!(matches!(ret, VMArrayRef(VMGcRef { .. })));
        ret
    }
}

impl VMArrayRef {
    /// Get the underlying `VMGcRef`.
    pub fn as_gc_ref(&self) -> &VMGcRef {
        &self.0
    }

    /// Clone this `VMArrayRef`, running any GC barriers as necessary.
    pub fn clone(&self, gc_store: &mut GcStore) -> Self {
        Self(gc_store.clone_gc_ref(&self.0))
    }

    /// Explicitly drop this `arrayref`, running GC drop barriers as necessary.
    pub fn drop(self, gc_store: &mut GcStore) {
        gc_store.drop_gc_ref(self.0);
    }

    /// Copy this `VMArrayRef` without running the GC's clone barriers.
    ///
    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
    /// escape hatch for collector implementations.
    ///
    /// Failure to run GC barriers when they would otherwise be necessary can
    /// lead to leaks, panics, and wrong results. It cannot lead to memory
    /// unsafety, however.
    pub fn unchecked_copy(&self) -> Self {
        Self(self.0.unchecked_copy())
    }

    /// Get the length of this array.
    pub fn len(&self, store: &StoreOpaque) -> Result<u32> {
        store.unwrap_gc_store().array_len(self)
    }

    /// Read an element of the given `StorageType` into a `Val`.
    ///
    /// `i8` and `i16` fields are zero-extended into `Val::I32(_)`s.
    ///
    /// Does not check that this array's elements are actually of type
    /// `ty`. That is the caller's responsibility. Failure to do so is memory
    /// safe, but will lead to general incorrectness such as panics and wrong
    /// results.
    ///
    /// Returns an error on out-of-bounds accesses.
    pub fn read_elem(
        &self,
        store: &mut AutoAssertNoGc,
        layout: &GcArrayLayout,
        ty: &StorageType,
        index: u32,
    ) -> Result<Val> {
        let offset = match layout.elem_offset(index) {
            Some(offset) => offset,
            None => bail_bug!("out-of-bounds array element index"),
        };
        self.as_gc_ref().read_val(store, ty, offset)
    }

    /// Write the given value into this array at the given offset.
    ///
    /// Returns an error if `val` is a GC reference that has since been
    /// unrooted.
    ///
    /// Does not check that `val` matches `ty`, nor that the field is actually
    /// of type `ty`. Checking those things is the caller's responsibility.
    /// Failure to do so is memory safe, but will lead to general incorrectness
    /// such as panics and wrong results.
    ///
    /// Returns an error on out-of-bounds accesses.
    pub fn write_elem(
        &self,
        store: &mut AutoAssertNoGc,
        layout: &GcArrayLayout,
        ty: &StorageType,
        index: u32,
        val: Val,
    ) -> Result<()> {
        debug_assert!(val._matches_ty(&store, &ty.unpack())?);

        let offset = match layout.elem_offset(index) {
            Some(offset) => offset,
            None => bail_bug!("out-of-bounds array element index"),
        };
        self.as_gc_ref().write_val(store, ty, offset, val)
    }

    /// Initialize an element in this arrayref that is currently uninitialized.
    ///
    /// The difference between this method and `write_elem` is that GC barriers
    /// are handled differently. When overwriting an initialized element (aka
    /// `write_elem`) we need to call the full write GC write barrier, which
    /// logically drops the old GC reference and clones the new GC
    /// reference. When we are initializing an element for the first time, there
    /// is no old GC reference that is being overwritten and which we need to
    /// drop, so we only need to clone the new GC reference.
    ///
    /// Calling this method on a arrayref that has already had the associated
    /// element initialized will result in GC bugs. These are memory safe but
    /// will lead to generally incorrect behavior such as panics, leaks, and
    /// incorrect results.
    ///
    /// Does not check that `val` matches `ty`, nor that the field is actually
    /// of type `ty`. Checking those things is the caller's responsibility.
    /// Failure to do so is memory safe, but will lead to general incorrectness
    /// such as panics and wrong results.
    ///
    /// Returns an error if `val` is a GC reference that has since been
    /// unrooted.
    ///
    /// Returns an error on out-of-bounds accesses.
    pub fn initialize_elem(
        &self,
        store: &mut AutoAssertNoGc,
        layout: &GcArrayLayout,
        ty: &StorageType,
        index: u32,
        val: Val,
    ) -> Result<()> {
        debug_assert!(val._matches_ty(&store, &ty.unpack())?);
        let offset = match layout.elem_offset(index) {
            Some(offset) => offset,
            None => bail_bug!("out-of-bounds array element index"),
        };
        self.as_gc_ref().initialize_val(store, ty, offset, val)
    }
}