refactor

fix-vm/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "fix-vm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+gc-arena = { workspace = true }
+hashbrown = { workspace = true }
+num_enum = { workspace = true }
+smallvec = { workspace = true }
+string-interner = { workspace = true }
+likely_stable = { workspace = true }
+sptr = "0.3"
+
+fix-builtins = { path = "../fix-builtins" }
+fix-codegen = { path = "../fix-codegen" }
+fix-common = { path = "../fix-common" }
+fix-error = { path = "../fix-error" }

fix-vm/src/boxing.rs

@@ -0,0 +1,486 @@
+#![allow(dead_code)]
+
+use std::fmt;
+use std::num::NonZeroU8;
+
+use sptr::Strict;
+
+const SIGN_MASK: u64 = 0x7FFF_FFFF_FFFF_FFFF;
+const QUIET_NAN: u64 = 0x7FF8_0000_0000_0000;
+const NEG_QUIET_NAN: u64 = 0xFFF8_0000_0000_0000;
+
+pub(crate) trait ArrayExt<const LEN: usize> {
+    type Elem;
+    fn truncate_to<const M: usize>(self) -> [Self::Elem; M];
+}
+
+impl<T: Default + Copy, const N: usize> ArrayExt<N> for [T; N] {
+    type Elem = T;
+    fn truncate_to<const M: usize>(self) -> [Self::Elem; M] {
+        let copy_len = usize::min(N, M);
+        let mut out = [T::default(); M];
+        out[0..copy_len].copy_from_slice(&self[0..copy_len]);
+        out
+    }
+}
+
+pub trait RawStore: Sized {
+    fn to_val(self, value: &mut Value);
+    fn from_val(value: &Value) -> Self;
+}
+
+impl RawStore for [u8; 6] {
+    #[inline]
+    fn to_val(self, value: &mut Value) {
+        value.set_data(self);
+    }
+
+    #[inline]
+    fn from_val(value: &Value) -> Self {
+        *value.data()
+    }
+}
+
+impl RawStore for bool {
+    #[inline]
+    fn to_val(self, value: &mut Value) {
+        value.set_data([u8::from(self)].truncate_to());
+    }
+
+    #[inline]
+    fn from_val(value: &Value) -> Self {
+        value.data()[0] == 1
+    }
+}
+
+macro_rules! int_store {
+    ($ty:ty) => {
+        impl RawStore for $ty {
+            #[inline]
+            fn to_val(self, value: &mut Value) {
+                let bytes = self.to_ne_bytes();
+                value.set_data(bytes.truncate_to());
+            }
+
+            #[inline]
+            fn from_val(value: &Value) -> Self {
+                <$ty>::from_ne_bytes(value.data().truncate_to())
+            }
+        }
+    };
+}
+
+int_store!(u8);
+int_store!(u16);
+int_store!(u32);
+
+int_store!(i8);
+int_store!(i16);
+int_store!(i32);
+
+fn store_ptr<P: Strict + Copy>(value: &mut Value, ptr: P) {
+    #[cfg(target_pointer_width = "64")]
+    {
+        assert!(
+            ptr.addr() <= 0x0000_FFFF_FFFF_FFFF,
+            "Pointer too large to store in NaN box"
+        );
+
+        let val = (unsafe { value.whole_mut() } as *mut [u8; 8]).cast::<P>();
+
+        let ptr = Strict::map_addr(ptr, |addr| {
+            addr | (usize::from(value.header().into_raw()) << 48)
+        });
+
+        unsafe { val.write(ptr) };
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    {
+        let _ = (value, ptr);
+        unimplemented!("32-bit pointer storage not supported");
+    }
+}
+
+fn load_ptr<P: Strict>(value: &Value) -> P {
+    #[cfg(target_pointer_width = "64")]
+    {
+        let val = (unsafe { value.whole() } as *const [u8; 8]).cast::<P>();
+        let ptr = unsafe { val.read() };
+        Strict::map_addr(ptr, |addr| addr & 0x0000_FFFF_FFFF_FFFF)
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    {
+        let _ = value;
+        unimplemented!("32-bit pointer storage not supported");
+    }
+}
+
+impl<T> RawStore for *const T {
+    fn to_val(self, value: &mut Value) {
+        store_ptr::<*const T>(value, self);
+    }
+
+    fn from_val(value: &Value) -> Self {
+        load_ptr::<*const T>(value)
+    }
+}
+
+impl<T> RawStore for *mut T {
+    fn to_val(self, value: &mut Value) {
+        store_ptr::<*mut T>(value, self);
+    }
+
+    fn from_val(value: &Value) -> Self {
+        load_ptr::<*mut T>(value)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum TagVal {
+    _P1,
+    _P2,
+    _P3,
+    _P4,
+    _P5,
+    _P6,
+    _P7,
+
+    _N1,
+    _N2,
+    _N3,
+    _N4,
+    _N5,
+    _N6,
+    _N7,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub(crate) struct RawTag(TagVal);
+
+impl RawTag {
+    #[inline]
+    #[must_use]
+    pub(crate) fn new(neg: bool, val: NonZeroU8) -> RawTag {
+        unsafe { Self::new_unchecked(neg, val.get() & 0x07) }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn new_checked(neg: bool, val: u8) -> Option<RawTag> {
+        Some(RawTag(match (neg, val) {
+            (false, 1) => TagVal::_P1,
+            (false, 2) => TagVal::_P2,
+            (false, 3) => TagVal::_P3,
+            (false, 4) => TagVal::_P4,
+            (false, 5) => TagVal::_P5,
+            (false, 6) => TagVal::_P6,
+            (false, 7) => TagVal::_P7,
+
+            (true, 1) => TagVal::_N1,
+            (true, 2) => TagVal::_N2,
+            (true, 3) => TagVal::_N3,
+            (true, 4) => TagVal::_N4,
+            (true, 5) => TagVal::_N5,
+            (true, 6) => TagVal::_N6,
+            (true, 7) => TagVal::_N7,
+
+            _ => return None,
+        }))
+    }
+
+    /// # Safety
+    ///
+    /// `val` must be in the range `1..8`
+    #[inline]
+    #[must_use]
+    pub(crate) unsafe fn new_unchecked(neg: bool, val: u8) -> RawTag {
+        RawTag(match (neg, val) {
+            (false, 1) => TagVal::_P1,
+            (false, 2) => TagVal::_P2,
+            (false, 3) => TagVal::_P3,
+            (false, 4) => TagVal::_P4,
+            (false, 5) => TagVal::_P5,
+            (false, 6) => TagVal::_P6,
+            (false, 7) => TagVal::_P7,
+
+            (true, 1) => TagVal::_N1,
+            (true, 2) => TagVal::_N2,
+            (true, 3) => TagVal::_N3,
+            (true, 4) => TagVal::_N4,
+            (true, 5) => TagVal::_N5,
+            (true, 6) => TagVal::_N6,
+            (true, 7) => TagVal::_N7,
+
+            _ => unsafe { core::hint::unreachable_unchecked() },
+        })
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn is_neg(self) -> bool {
+        matches!(self.0, |TagVal::_N1| TagVal::_N2
+            | TagVal::_N3
+            | TagVal::_N4
+            | TagVal::_N5
+            | TagVal::_N6
+            | TagVal::_N7)
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn val(self) -> NonZeroU8 {
+        match self.0 {
+            TagVal::_P1 | TagVal::_N1 => NonZeroU8::MIN,
+            TagVal::_P2 | TagVal::_N2 => NonZeroU8::MIN.saturating_add(1),
+            TagVal::_P3 | TagVal::_N3 => NonZeroU8::MIN.saturating_add(2),
+            TagVal::_P4 | TagVal::_N4 => NonZeroU8::MIN.saturating_add(3),
+            TagVal::_P5 | TagVal::_N5 => NonZeroU8::MIN.saturating_add(4),
+            TagVal::_P6 | TagVal::_N6 => NonZeroU8::MIN.saturating_add(5),
+            TagVal::_P7 | TagVal::_N7 => NonZeroU8::MIN.saturating_add(6),
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn neg_val(self) -> (bool, u8) {
+        match self.0 {
+            TagVal::_P1 => (false, 1),
+            TagVal::_P2 => (false, 2),
+            TagVal::_P3 => (false, 3),
+            TagVal::_P4 => (false, 4),
+            TagVal::_P5 => (false, 5),
+            TagVal::_P6 => (false, 6),
+            TagVal::_P7 => (false, 7),
+            TagVal::_N1 => (true, 1),
+            TagVal::_N2 => (true, 2),
+            TagVal::_N3 => (true, 3),
+            TagVal::_N4 => (true, 4),
+            TagVal::_N5 => (true, 5),
+            TagVal::_N6 => (true, 6),
+            TagVal::_N7 => (true, 7),
+        }
+    }
+}
+
+impl fmt::Debug for RawTag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawTag")
+            .field("neg", &self.is_neg())
+            .field("val", &self.val())
+            .finish()
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+struct Header(u16);
+
+impl Header {
+    #[inline]
+    fn new(tag: RawTag) -> Header {
+        let (neg, val) = tag.neg_val();
+        Header(0x7FF8 | (u16::from(neg) << 15) | u16::from(val))
+    }
+
+    #[inline]
+    fn tag(self) -> RawTag {
+        unsafe { RawTag::new_unchecked(self.get_sign(), self.get_tag()) }
+    }
+
+    #[inline]
+    fn get_sign(self) -> bool {
+        self.0 & 0x8000 != 0
+    }
+
+    #[inline]
+    fn get_tag(self) -> u8 {
+        (self.0 & 0x0007) as u8
+    }
+
+    #[inline]
+    fn into_raw(self) -> u16 {
+        self.0
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(C, align(8))]
+pub(crate) struct Value {
+    #[cfg(target_endian = "big")]
+    header: Header,
+    data: [u8; 6],
+    #[cfg(target_endian = "little")]
+    header: Header,
+}
+
+impl Value {
+    #[inline]
+    pub(crate) fn new(tag: RawTag, data: [u8; 6]) -> Value {
+        Value {
+            header: Header::new(tag),
+            data,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn empty(tag: RawTag) -> Value {
+        Value::new(tag, [0; 6])
+    }
+
+    pub(crate) fn store<T: RawStore>(tag: RawTag, val: T) -> Value {
+        let mut v = Value::new(tag, [0; 6]);
+        T::to_val(val, &mut v);
+        v
+    }
+
+    pub(crate) fn load<T: RawStore>(self) -> T {
+        T::from_val(&self)
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn tag(&self) -> RawTag {
+        self.header.tag()
+    }
+
+    #[inline]
+    fn header(&self) -> &Header {
+        &self.header
+    }
+
+    #[inline]
+    pub(crate) fn set_data(&mut self, val: [u8; 6]) {
+        self.data = val;
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn data(&self) -> &[u8; 6] {
+        &self.data
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn data_mut(&mut self) -> &mut [u8; 6] {
+        &mut self.data
+    }
+
+    #[inline]
+    #[must_use]
+    unsafe fn whole(&self) -> &[u8; 8] {
+        let ptr = (self as *const Value).cast::<[u8; 8]>();
+        unsafe { &*ptr }
+    }
+
+    #[inline]
+    #[must_use]
+    unsafe fn whole_mut(&mut self) -> &mut [u8; 8] {
+        let ptr = (self as *mut Value).cast::<[u8; 8]>();
+        unsafe { &mut *ptr }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub(crate) union RawBox {
+    float: f64,
+    value: Value,
+    bits: u64,
+    #[cfg(target_pointer_width = "64")]
+    ptr: *const (),
+    #[cfg(target_pointer_width = "32")]
+    ptr: (u32, *const ()),
+}
+
+impl RawBox {
+    #[inline]
+    #[must_use]
+    pub(crate) fn from_float(val: f64) -> RawBox {
+        match (val.is_nan(), val.is_sign_positive()) {
+            (true, true) => RawBox {
+                float: f64::from_bits(QUIET_NAN),
+            },
+            (true, false) => RawBox {
+                float: f64::from_bits(NEG_QUIET_NAN),
+            },
+            (false, _) => RawBox { float: val },
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn from_value(value: Value) -> RawBox {
+        RawBox { value }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn tag(&self) -> Option<RawTag> {
+        if self.is_value() {
+            Some(unsafe { self.value.tag() })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn is_float(&self) -> bool {
+        (unsafe { !self.float.is_nan() } || unsafe { self.bits & SIGN_MASK == QUIET_NAN })
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn is_value(&self) -> bool {
+        (unsafe { self.float.is_nan() } && unsafe { self.bits & SIGN_MASK != QUIET_NAN })
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn float(&self) -> Option<&f64> {
+        if self.is_float() {
+            Some(unsafe { &self.float })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn value(&self) -> Option<&Value> {
+        if self.is_value() {
+            Some(unsafe { &self.value })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub(crate) fn into_float_unchecked(self) -> f64 {
+        unsafe { self.float }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) fn to_bits(self) -> u64 {
+        unsafe { self.bits }
+    }
+}
+
+impl fmt::Debug for RawBox {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.float() {
+            Some(val) => f.debug_tuple("RawBox::Float").field(val).finish(),
+            None => {
+                let val = self.value().expect("RawBox is neither float nor value");
+
+                f.debug_struct("RawBox::Data")
+                    .field("tag", &val.tag())
+                    .field("data", val.data())
+                    .finish()
+            }
+        }
+    }
+}

fix-vm/src/helpers.rs

@@ -0,0 +1,18 @@
+use fix_error::Error;
+
+use crate::value::StrictValue;
+use crate::{NixNum, VmError};
+
+pub(super) fn vm_err(msg: impl Into<String>) -> VmError {
+    VmError::Uncatchable(Error::eval_error(msg.into()))
+}
+
+pub(super) fn get_num(val: StrictValue<'_>) -> Option<NixNum> {
+    if let Some(i) = val.as_inline::<i32>() {
+        Some(NixNum::Int(i as i64))
+    } else if let Some(gc_i) = val.as_gc::<i64>() {
+        Some(NixNum::Int(*gc_i))
+    } else {
+        val.as_float().map(NixNum::Float)
+    }
+}

fix-vm/src/stack.rs

@@ -0,0 +1,76 @@
+use std::mem::MaybeUninit;
+
+use gc_arena::Collect;
+
+pub(super) struct Stack<const N: usize, T> {
+    inner: Box<[MaybeUninit<T>; N]>,
+    len: usize,
+}
+
+unsafe impl<'gc, const N: usize, T: Collect<'gc> + 'gc> Collect<'gc> for Stack<N, T> {
+    const NEEDS_TRACE: bool = T::NEEDS_TRACE;
+    fn trace<U: gc_arena::collect::Trace<'gc>>(&self, cc: &mut U) {
+        for item in self.inner[..self.len].iter() {
+            unsafe {
+                item.assume_init_ref().trace(cc);
+            }
+        }
+    }
+}
+
+impl<const N: usize, T> Default for Stack<N, T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<const N: usize, T> Stack<N, T> {
+    pub(super) fn new() -> Self {
+        Self {
+            inner: Box::new([const { MaybeUninit::uninit() }; N]),
+            len: 0,
+        }
+    }
+
+    pub(super) fn push(&mut self, val: T) -> Result<(), T> {
+        if self.len == N {
+            return Err(val);
+        }
+        unsafe {
+            self.inner.get_unchecked_mut(self.len).write(val);
+        }
+        self.len += 1;
+        Ok(())
+    }
+
+    pub(super) fn pop(&mut self) -> Option<T> {
+        if self.len == 0 {
+            return None;
+        }
+        let ret = unsafe {
+            self.inner
+                .get_unchecked_mut(self.len - 1)
+                .assume_init_read()
+        };
+        self.len -= 1;
+        Some(ret)
+    }
+
+    pub(super) fn tos(&self) -> Option<&T> {
+        if self.len == 0 {
+            return None;
+        }
+        Some(unsafe { self.inner.get_unchecked(self.len - 1).assume_init_ref() })
+    }
+
+    pub(super) fn tos_mut(&mut self) -> Option<&mut T> {
+        if self.len == 0 {
+            return None;
+        }
+        Some(unsafe { self.inner.get_unchecked_mut(self.len - 1).assume_init_mut() })
+    }
+
+    pub(super) fn len(&self) -> usize {
+        self.len
+    }
+}

fix-vm/src/value.rs

@@ -0,0 +1,583 @@
+#![allow(dead_code)]
+
+use std::fmt;
+use std::marker::PhantomData;
+use std::mem::size_of;
+use std::ops::Deref;
+
+use fix_builtins::BuiltinId;
+use fix_common::*;
+use gc_arena::collect::Trace;
+use gc_arena::{Collect, Gc, GcRefLock, Mutation, RefLock};
+use num_enum::TryFromPrimitive;
+use smallvec::SmallVec;
+use string_interner::Symbol;
+use string_interner::symbol::SymbolU32;
+
+use crate::NixNum;
+use crate::boxing::{RawBox, RawStore, RawTag, Value as RawValue};
+
+mod private {
+    pub trait Cealed {}
+}
+
+/// # Safety
+/// 1. TAG must be unique among all implementors.
+/// 2. TAG must be within 1..=7
+pub(crate) unsafe trait Storable: private::Cealed {
+    const TAG: (bool, u8);
+}
+pub(crate) trait InlineStorable: Storable + RawStore {}
+pub(crate) trait GcStorable: Storable {}
+
+macro_rules! define_value_types {
+    (
+        inline { $($itype:ty => $itag:expr, $iname:literal;)* }
+        gc { $($gtype:ty => $gtag:expr, $gname:literal;)* }
+    ) => {
+        $(
+        unsafe impl Storable for $itype {
+            const TAG: (bool, u8) = $itag;
+        }
+        impl InlineStorable for $itype {}
+        impl private::Cealed for $itype {}
+        )*
+        $(
+        unsafe impl Storable for $gtype {
+            const TAG: (bool, u8) = $gtag;
+        }
+        impl GcStorable for $gtype {}
+        impl private::Cealed for $gtype {}
+        )*
+
+        const _: () = assert!(size_of::<Value<'static>>() == 8);
+        $(const _: () = assert!(size_of::<$itype>() <= 6);)*
+        $(const _: () = { let (_, val) = $itag; assert!(val >= 1 && val <= 7); };)*
+        $(const _: () = { let (_, val) = $gtag; assert!(val >= 1 && val <= 7); };)*
+
+        const _: () = {
+            let tags: &[(bool, u8)] = &[$($itag),*, $($gtag),*];
+            let mut mask_false: u8 = 0;
+            let mut mask_true: u8 = 0;
+            let mut i = 0;
+            while i < tags.len() {
+                let (neg, val) = tags[i];
+                let bit = 1 << val;
+                if neg {
+                    assert!(mask_true & bit == 0, "duplicate true tag id");
+                    mask_true |= bit;
+                } else {
+                    assert!(mask_false & bit == 0, "duplicate false tag id");
+                    mask_false |= bit;
+                }
+                i += 1;
+            }
+        };
+
+        unsafe impl<'gc> Collect<'gc> for Value<'gc> {
+            const NEEDS_TRACE: bool = true;
+            fn trace<T: Trace<'gc>>(&self, cc: &mut T) {
+                let Some(tag) = self.raw.tag() else { return };
+                match tag.neg_val() {
+                    $(<$gtype as Storable>::TAG => unsafe {
+                        self.load_gc::<$gtype>().trace(cc)
+                    },)*
+                    $(<$itype as Storable>::TAG => (),)*
+                    (neg, val) => unreachable!("invalid tag: neg={neg}, val={val}"),
+                }
+            }
+        }
+
+        impl fmt::Debug for Value<'_> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self.tag() {
+                    None => write!(f, "Float({:?})", unsafe {
+                        self.raw.float().unwrap_unchecked()
+                    }),
+                    $(Some(<$itype as Storable>::TAG) => write!(f, "{}({:?})", $iname, unsafe {
+                        self.as_inline::<$itype>().unwrap_unchecked()
+                    }),)*
+                    $(Some(<$gtype as Storable>::TAG) =>
+                        write!(f, "{}(..)", $gname),)*
+                    Some((neg, val)) => write!(f, "Unknown(neg={neg}, val={val})"),
+                }
+            }
+        }
+    };
+}
+
+define_value_types! {
+    inline {
+        i32 => (false, 1), "SmallInt";
+        bool => (false, 2), "Bool";
+        Null => (false, 3), "Null";
+        StringId => (false, 4), "SmallString";
+        PrimOp => (false, 5), "PrimOp";
+    }
+    gc {
+        i64 => (false, 6), "BigInt";
+        NixString => (false, 7), "String";
+        AttrSet<'_> => (true, 1), "AttrSet";
+        List<'_> => (true, 2), "List";
+        Thunk<'_> => (true, 3), "Thunk";
+        Closure<'_> => (true, 4), "Closure";
+        PrimOpApp<'_> => (true, 5), "PrimOpApp";
+    }
+}
+
+/// # Nix runtime value representation
+///
+/// NaN-boxed value fitting in 8 bytes.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub(crate) struct Value<'gc> {
+    raw: RawBox,
+    _marker: PhantomData<Gc<'gc, ()>>,
+}
+
+impl Default for Value<'_> {
+    #[inline(always)]
+    fn default() -> Self {
+        Self::new_inline(Null)
+    }
+}
+
+impl<'gc> Value<'gc> {
+    #[inline(always)]
+    fn from_raw_value(rv: RawValue) -> Self {
+        Self {
+            raw: RawBox::from_value(rv),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Load a GC pointer from a value with a negative tag.
+    ///
+    /// # Safety
+    ///
+    /// The value must actually store a `Gc<'gc, T>` with the matching type.
+    #[inline(always)]
+    unsafe fn load_gc<T: GcStorable>(self) -> Gc<'gc, T> {
+        unsafe {
+            let rv = self.raw.value().unwrap_unchecked();
+            let ptr: *const T = <*const T as RawStore>::from_val(rv);
+            Gc::from_ptr(ptr)
+        }
+    }
+
+    /// Returns the `(negative, val)` tag, or `None` for a float.
+    #[inline(always)]
+    fn tag(self) -> Option<(bool, u8)> {
+        self.raw.tag().map(|t| t.neg_val())
+    }
+}
+
+impl<'gc> Value<'gc> {
+    #[inline]
+    pub(crate) fn new_float(val: f64) -> Self {
+        Self {
+            raw: RawBox::from_float(val),
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn new_inline<T: InlineStorable>(val: T) -> Self {
+        Self::from_raw_value(RawValue::store(
+            unsafe { RawTag::new_unchecked(T::TAG.0, T::TAG.1) },
+            val,
+        ))
+    }
+
+    #[inline]
+    pub(crate) fn new_gc<T: GcStorable>(gc: Gc<'gc, T>) -> Self {
+        let ptr = Gc::as_ptr(gc);
+        Self::from_raw_value(RawValue::store(
+            unsafe { RawTag::new_unchecked(T::TAG.0, T::TAG.1) },
+            ptr,
+        ))
+    }
+
+    #[inline]
+    pub(crate) fn make_int(val: i64, mc: &Mutation<'gc>) -> Self {
+        if val >= i32::MIN as i64 && val <= i32::MAX as i64 {
+            Value::new_inline(val as i32)
+        } else {
+            Value::new_gc(Gc::new(mc, val))
+        }
+    }
+}
+
+impl<'gc> Value<'gc> {
+    #[inline]
+    pub(crate) fn is_float(self) -> bool {
+        self.raw.is_float()
+    }
+
+    #[inline]
+    pub(crate) fn is<T: Storable>(self) -> bool {
+        self.tag() == Some(T::TAG)
+    }
+}
+
+impl<'gc> Value<'gc> {
+    #[inline]
+    pub(crate) fn as_float(self) -> Option<f64> {
+        self.raw.float().copied()
+    }
+
+    #[inline]
+    pub(crate) fn as_inline<T: InlineStorable>(self) -> Option<T> {
+        if self.is::<T>() {
+            Some(unsafe {
+                let rv = self.raw.value().unwrap_unchecked();
+                T::from_val(rv)
+            })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub(crate) fn as_gc<T: GcStorable>(self) -> Option<Gc<'gc, T>> {
+        if self.is::<T>() {
+            Some(unsafe {
+                let rv = self.raw.value().unwrap_unchecked();
+                let ptr: *const T = <*const T as RawStore>::from_val(rv);
+                Gc::from_ptr(ptr)
+            })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub(crate) fn as_num(self) -> Option<NixNum> {
+        if let Some(i) = self.as_inline::<i32>() {
+            Some(NixNum::Int(i as i64))
+        } else if let Some(gc_i) = self.as_gc::<i64>() {
+            Some(NixNum::Int(*gc_i))
+        } else {
+            self.as_float().map(NixNum::Float)
+        }
+    }
+
+    #[inline]
+    pub(crate) fn restrict(self) -> Option<StrictValue<'gc>> {
+        if !self.is::<Thunk<'gc>>() {
+            Some(StrictValue(self))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Copy, Clone, Default)]
+#[repr(transparent)]
+pub struct StaticValue(Value<'static>);
+
+impl<'gc> From<StaticValue> for Value<'gc> {
+    #[inline]
+    fn from(value: StaticValue) -> Self {
+        // SAFETY: StaticValue is guaranteed to not contain any `Gc`.
+        unsafe { std::mem::transmute::<Value<'static>, Value<'gc>>(value.0) }
+    }
+}
+
+impl StaticValue {
+    #[inline]
+    pub fn new_float(val: f64) -> Self {
+        Self(Value::new_float(val))
+    }
+    #[inline]
+    pub fn new_inline<T: InlineStorable>(val: T) -> Self {
+        Self(Value::new_inline(val))
+    }
+    #[inline]
+    pub fn new_primop(id: BuiltinId, arity: u8) -> Self {
+        Self(Value::new_inline(PrimOp { id, arity }))
+    }
+    #[inline]
+    pub fn is_float(self) -> bool {
+        self.0.is_float()
+    }
+    #[inline]
+    pub fn is<T: InlineStorable>(self) -> bool {
+        self.0.is::<T>()
+    }
+    #[inline]
+    pub fn as_float(self) -> Option<f64> {
+        self.0.as_float()
+    }
+    #[inline]
+    pub fn as_inline<T: InlineStorable>(self) -> Option<T> {
+        self.0.as_inline::<T>()
+    }
+    #[inline]
+    pub fn to_bits(self) -> u64 {
+        self.0.raw.to_bits()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Null;
+impl RawStore for Null {
+    fn to_val(self, value: &mut RawValue) {
+        value.set_data([0; 6]);
+    }
+    fn from_val(_: &RawValue) -> Self {
+        Self
+    }
+}
+
+impl RawStore for StringId {
+    fn to_val(self, value: &mut RawValue) {
+        (self.0.to_usize() as u32).to_val(value);
+    }
+    fn from_val(value: &RawValue) -> Self {
+        Self(
+            SymbolU32::try_from_usize(u32::from_val(value) as usize)
+                .expect("failed to read StringId from Value"),
+        )
+    }
+}
+
+/// Heap-allocated Nix string.
+///
+/// Stored on the GC heap via `Gc<'gc, NixString>`. The string data itself
+/// lives in a standard `Box<str>` owned by this struct; the GC only manages
+/// the outer allocation.
+#[derive(Collect)]
+#[collect(require_static)]
+pub(crate) struct NixString {
+    data: Box<str>,
+    // TODO: string context for derivation dependency tracking
+}
+
+impl NixString {
+    pub(crate) fn new(s: impl Into<Box<str>>) -> Self {
+        Self { data: s.into() }
+    }
+
+    pub(crate) fn as_str(&self) -> &str {
+        &self.data
+    }
+}
+
+impl fmt::Debug for NixString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.data, f)
+    }
+}
+
+#[derive(Collect, Debug, Default)]
+#[collect(no_drop)]
+pub(crate) struct AttrSet<'gc> {
+    entries: SmallVec<[(StringId, Value<'gc>); 4]>,
+}
+
+impl<'gc> Deref for AttrSet<'gc> {
+    type Target = [(StringId, Value<'gc>)];
+    fn deref(&self) -> &Self::Target {
+        &self.entries
+    }
+}
+
+impl<'gc> AttrSet<'gc> {
+    pub(crate) fn from_sorted_unchecked(
+        entries: SmallVec<[(StringId, Value<'gc>); 4]>,
+    ) -> Self {
+        debug_assert!(entries.is_sorted_by_key(|(key, _)| *key));
+        Self { entries }
+    }
+
+    pub(crate) fn lookup(&self, key: StringId) -> Option<Value<'gc>> {
+        self.entries
+            .binary_search_by_key(&key, |(k, _)| *k)
+            .ok()
+            .map(|i| self.entries[i].1)
+    }
+
+    pub(crate) fn has(&self, key: StringId) -> bool {
+        self.entries.binary_search_by_key(&key, |(k, _)| *k).is_ok()
+    }
+
+    pub(crate) fn merge(&self, other: &Self, mc: &Mutation<'gc>) -> Gc<'gc, Self> {
+        use std::cmp::Ordering::*;
+
+        debug_assert!(self.entries.is_sorted_by_key(|(key, _)| *key));
+        debug_assert!(other.entries.is_sorted_by_key(|(key, _)| *key));
+
+        let mut entries = SmallVec::new();
+        let mut i = 0;
+        let mut j = 0;
+        while i < self.entries.len() && j < other.entries.len() {
+            match self.entries[i].0.cmp(&other.entries[j].0) {
+                Less => {
+                    entries.push(self.entries[i]);
+                    i += 1;
+                }
+                Greater => {
+                    entries.push(other.entries[j]);
+                    j += 1;
+                }
+                Equal => {
+                    entries.push(other.entries[j]);
+                    i += 1;
+                    j += 1;
+                }
+            }
+        }
+        entries.extend(other.entries[j..].iter().cloned());
+        entries.extend(self.entries[i..].iter().cloned());
+
+        debug_assert!(entries.is_sorted_by_key(|(key, _)| *key));
+
+        Gc::new(mc, AttrSet { entries })
+    }
+}
+
+#[derive(Collect, Debug, Default)]
+#[collect(no_drop)]
+pub(crate) struct List<'gc> {
+    pub(crate) inner: SmallVec<[Value<'gc>; 4]>,
+}
+impl<'gc> Deref for List<'gc> {
+    type Target = SmallVec<[Value<'gc>; 4]>;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+pub(crate) type Thunk<'gc> = RefLock<ThunkState<'gc>>;
+
+#[derive(Collect, Debug)]
+#[collect(no_drop)]
+pub(crate) enum ThunkState<'gc> {
+    Pending {
+        ip: usize,
+        env: GcEnv<'gc>,
+        with_env: Option<GcWithEnv<'gc>>,
+    },
+    Apply {
+        func: Value<'gc>,
+        arg: Value<'gc>,
+    },
+    Blackhole,
+    Evaluated(Value<'gc>),
+}
+
+#[derive(Collect, Debug)]
+#[collect(no_drop)]
+pub(crate) struct Env<'gc> {
+    pub(crate) locals: SmallVec<[Value<'gc>; 4]>,
+    pub(crate) prev: Option<GcEnv<'gc>>,
+}
+pub(crate) type GcEnv<'gc> = GcRefLock<'gc, Env<'gc>>;
+
+#[derive(Collect, Debug)]
+#[collect(no_drop)]
+pub(crate) struct WithEnv<'gc> {
+    pub(crate) env: Value<'gc>,
+    pub(crate) prev: Option<GcWithEnv<'gc>>,
+}
+pub(crate) type GcWithEnv<'gc> = Gc<'gc, WithEnv<'gc>>;
+
+impl<'gc> Env<'gc> {
+    pub(crate) fn empty() -> Self {
+        Env {
+            locals: SmallVec::new(),
+            prev: None,
+        }
+    }
+
+    pub(crate) fn with_arg(
+        arg: Value<'gc>,
+        n_locals: u32,
+        prev: Gc<'gc, RefLock<Env<'gc>>>,
+    ) -> Self {
+        let mut locals = smallvec::smallvec![Value::default(); 1 + n_locals as usize];
+        locals[0] = arg;
+        Env {
+            locals,
+            prev: Some(prev),
+        }
+    }
+}
+
+#[derive(Collect, Debug)]
+#[collect(no_drop)]
+pub(crate) struct Closure<'gc> {
+    pub(crate) ip: u32,
+    pub(crate) n_locals: u32,
+    pub(crate) env: Gc<'gc, RefLock<Env<'gc>>>,
+    pub(crate) pattern: Option<Gc<'gc, PatternInfo>>,
+}
+
+#[derive(Collect, Debug)]
+#[collect(require_static)]
+pub(crate) struct PatternInfo {
+    pub(crate) required: SmallVec<[StringId; 4]>,
+    pub(crate) optional: SmallVec<[StringId; 4]>,
+    pub(crate) ellipsis: bool,
+    pub(crate) param_spans: Box<[(StringId, u32)]>,
+}
+
+#[derive(Clone, Copy, Debug, Collect)]
+#[collect(require_static)]
+pub(crate) struct PrimOp {
+    pub(crate) id: BuiltinId,
+    pub(crate) arity: u8,
+}
+
+impl RawStore for PrimOp {
+    fn to_val(self, value: &mut RawValue) {
+        value.set_data([0, 0, 0, 0, self.id as u8, self.arity]);
+    }
+    fn from_val(value: &RawValue) -> Self {
+        let [.., id, arity] = *value.data();
+        Self {
+            id: BuiltinId::try_from_primitive(id).expect("invalid BuiltinId"),
+            arity,
+        }
+    }
+}
+
+#[derive(Collect, Debug)]
+#[collect(no_drop)]
+pub(crate) struct PrimOpApp<'gc> {
+    pub(crate) primop: PrimOp,
+    pub(crate) args: SmallVec<[Value<'gc>; 2]>,
+}
+
+#[derive(Copy, Clone, Default)]
+#[repr(transparent)]
+pub(crate) struct StrictValue<'gc>(Value<'gc>);
+
+impl<'gc> StrictValue<'gc> {
+    #[inline]
+    pub(crate) fn relax(self) -> Value<'gc> {
+        self.0
+    }
+}
+
+impl<'gc> Deref for StrictValue<'gc> {
+    type Target = Value<'gc>;
+    #[inline]
+    fn deref(&self) -> &Value<'gc> {
+        &self.0
+    }
+}
+
+impl fmt::Debug for StrictValue<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+unsafe impl<'gc> Collect<'gc> for StrictValue<'gc> {
+    const NEEDS_TRACE: bool = true;
+    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
+        self.0.trace(cc);
+    }
+}