implement fixed size lists host side

Author: cpetig

crates/environ/src/component/types.rs

@@ -751,6 +751,23 @@ impl CanonicalAbiInfo {
         return ret;
     }
 
+    /// Returns the abi for a fixed size list
+    pub const fn fixed_size_list_static(
+        element: &CanonicalAbiInfo,
+        count: u32,
+    ) -> CanonicalAbiInfo {
+        CanonicalAbiInfo {
+            size32: element.size32 * count,
+            align32: element.align32,
+            size64: element.size64 * count,
+            align64: element.align64,
+            flat_count: match element.flat_count {
+                None => None,
+                Some(c) => Some(c.saturating_mul(if count > 255 { 255u8 } else { count as u8 })),
+            },
+        }
+    }
+
     /// Returns the delta from the current value of `offset` to align properly
     /// and read the next record field of type `abi` for 32-bit memories.
     pub fn next_field32(&self, offset: &mut u32) -> u32 {

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -2970,6 +2970,142 @@ macro_rules! impl_component_ty_for_tuples {
 
 for_each_function_signature!(impl_component_ty_for_tuples);
 
+unsafe impl<T, const N: usize> ComponentType for [T; N]
+where
+    T: ComponentType,
+{
+    type Lower = [T::Lower; N];
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::fixed_size_list_static(&T::ABI, N as u32);
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::FixedSizeList(t) => T::typecheck(&types.types[*t].element, types),
+            other => bail!("expected `list<_, N>` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl<T, const N: usize> Lower for [T; N]
+where
+    T: Lower,
+{
+    fn linear_lower_to_flat<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        let element = match ty {
+            InterfaceType::FixedSizeList(ty) => cx.types[ty].element,
+            _ => bad_type_info(),
+        };
+        for (i, val) in self.iter().enumerate() {
+            val.linear_lower_to_flat(cx, element, map_maybe_uninit!(dst[i]))?;
+        }
+        Ok(())
+    }
+
+    fn linear_lower_to_memory<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
+        let element = match ty {
+            InterfaceType::FixedSizeList(ty) => cx.types[ty].element,
+            _ => bad_type_info(),
+        };
+        for (i, val) in self.iter().enumerate() {
+            val.linear_lower_to_memory(cx, element, offset + i * T::SIZE32)?;
+        }
+        Ok(())
+    }
+}
+
+unsafe impl<T, const N: usize> Lift for [T; N]
+where
+    T: Lift + Sized,
+{
+    fn linear_lift_from_flat(
+        cx: &mut LiftContext<'_>,
+        ty: InterfaceType,
+        src: &Self::Lower,
+    ) -> Result<Self> {
+        let element = match ty {
+            InterfaceType::FixedSizeList(ty) => cx.types[ty].element,
+            _ => bad_type_info(),
+        };
+        // this is reimplementation of array::try_from_fn
+        let mut valid = 0;
+        let mut result: [MaybeUninit<T>; N] = [const { MaybeUninit::uninit() }; N];
+        let mut error: Option<crate::error::Error> = None;
+        for n in 0..N {
+            match T::linear_lift_from_flat(cx, element, &src[n]) {
+                Ok(v) => {
+                    result[valid].write(v);
+                    valid += 1;
+                }
+                Err(e) => {
+                    error = Some(e);
+                    // continue to consume all input
+                }
+            }
+        }
+        if let Some(e) = error {
+            for n in 0..valid {
+                unsafe {
+                    result[n].assume_init_drop();
+                }
+            }
+            return Err(e);
+        }
+        assert!(valid == N);
+        Ok(unsafe { core::mem::transmute::<_, Self>(result) })
+    }
+
+    fn linear_lift_from_memory(
+        cx: &mut LiftContext<'_>,
+        ty: InterfaceType,
+        bytes: &[u8],
+    ) -> Result<Self> {
+        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+        let element = match ty {
+            InterfaceType::FixedSizeList(ty) => cx.types[ty].element,
+            _ => bad_type_info(),
+        };
+        // this is reimplementation of array::try_from_fn
+        let mut valid = 0;
+        let mut result: [MaybeUninit<T>; N] = [const { MaybeUninit::uninit() }; N];
+        let mut error: Option<crate::error::Error> = None;
+        let mut offset = 0;
+        for _ in 0..N {
+            match T::linear_lift_from_memory(cx, element, &bytes[offset..offset + T::SIZE32]) {
+                Ok(v) => {
+                    result[valid].write(v);
+                    valid += 1;
+                }
+                Err(e) => {
+                    error = Some(e);
+                    // continue to consume all input
+                }
+            }
+            offset += T::SIZE32;
+        }
+        if let Some(e) = error {
+            for n in 0..valid {
+                unsafe {
+                    result[n].assume_init_drop();
+                }
+            }
+            return Err(e);
+        }
+        assert!(valid == N);
+        Ok(unsafe { core::mem::transmute::<_, Self>(result) })
+    }
+}
+
 pub fn desc(ty: &InterfaceType) -> &'static str {
     match ty {
         InterfaceType::U8 => "u8",

crates/wasmtime/src/runtime/component/types.rs

@@ -10,7 +10,7 @@ use core::ops::Deref;
 use wasmtime_environ::PanicOnOom as _;
 use wasmtime_environ::component::{
     ComponentTypes, Export, InterfaceType, ResourceIndex, TypeComponentIndex,
-    TypeComponentInstanceIndex, TypeDef, TypeEnumIndex, TypeFlagsIndex, TypeFuncIndex,
+    TypeComponentInstanceIndex, TypeDef, TypeEnumIndex, TypeFixedSizeListIndex, TypeFlagsIndex, TypeFuncIndex,
     TypeFutureIndex, TypeFutureTableIndex, TypeListIndex, TypeMapIndex, TypeModuleIndex,
     TypeOptionIndex, TypeRecordIndex, TypeResourceTable, TypeResourceTableIndex, TypeResultIndex,
     TypeStreamIndex, TypeStreamTableIndex, TypeTupleIndex, TypeVariantIndex, alternate_lookup_key,
@@ -165,7 +165,10 @@ impl TypeChecker<'_> {
             (InterfaceType::Stream(_), _) => false,
             (InterfaceType::ErrorContext(_), InterfaceType::ErrorContext(_)) => true,
             (InterfaceType::ErrorContext(_), _) => false,
-            (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)
+            (InterfaceType::FixedLengthList(t1), InterfaceType::FixedSizeList(t2)) => {
+                self.fixed_length_lists_equal(t1, t2)
+            }
+            (InterfaceType::FixedSizeList(_), _) => false,
         }
     }
 
@@ -181,6 +184,19 @@ impl TypeChecker<'_> {
         self.interface_types_equal(a.key, b.key) && self.interface_types_equal(a.value, b.value)
     }
 
+    fn fixed_length_lists_equal(
+        &self,
+        l1: wasmtime_environ::component::TypeFixedLengthListIndex,
+        l2: wasmtime_environ::component::TypeFixedLengthListIndex,
+    ) -> bool {
+        let a = &self.a_types[l1];
+        let b = &self.b_types[l2];
+        if a.size != b.size {
+            return false;
+        }
+        self.interface_types_equal(a.element, b.element)
+    }
+
     fn resources_equal(&self, o1: TypeResourceTableIndex, o2: TypeResourceTableIndex) -> bool {
         match (&self.a_types[o1], &self.b_types[o2]) {
             // Concrete resource types are the same if they map back to the
@@ -365,6 +381,34 @@ impl Map {
         Type::from(&self.0.types[self.0.index].value, &self.0.instance())
     }
 }
+/// A `list` interface type
+#[derive(Clone, Debug)]
+pub struct FixedLengthList(Handle<TypeFixedLengthListIndex>);
+
+impl PartialEq for FixedLengthList {
+    fn eq(&self, other: &Self) -> bool {
+        self.0
+            .equivalent(&other.0, TypeChecker::fixed_size_lists_equal)
+    }
+}
+
+impl Eq for FixedLengthList {}
+
+impl FixedLengthList {
+    pub(crate) fn from(index: TypeFixedLengthListIndex, ty: &InstanceType<'_>) -> Self {
+        FixedLengthList(Handle::new(index, ty))
+    }
+
+    /// Retrieve the element type of this `list`.
+    pub fn ty(&self) -> Type {
+        Type::from(&self.0.types[self.0.index].element, &self.0.instance())
+    }
+
+    /// Retrieve the size of this `list`.
+    pub fn size(&self) -> u32 {
+        self.0.types[self.0.index].size
+    }
+}
 
 /// A field declaration belonging to a `record`
 #[derive(Debug)]
@@ -738,6 +782,7 @@ pub enum Type {
     Future(FutureType),
     Stream(StreamType),
     ErrorContext,
+    FixedSizeList(FixedSizeList),
 }
 
 impl Type {
@@ -899,7 +944,9 @@ impl Type {
             InterfaceType::Future(index) => Type::Future(instance.future_type(*index)),
             InterfaceType::Stream(index) => Type::Stream(instance.stream_type(*index)),
             InterfaceType::ErrorContext(_) => Type::ErrorContext,
-            InterfaceType::FixedLengthList(_) => todo!(), // FIXME(#12279)
+            InterfaceType::FixedLengthList(index) => {
+                Type::FixedLengthList(FixedSizeList::from(*index, instance))
+            }
         }
     }
 
@@ -932,6 +979,7 @@ impl Type {
             Type::Future(_) => "future",
             Type::Stream(_) => "stream",
             Type::ErrorContext => "error-context",
+            Type::FixedSizeList(_) => "list<_, N>",
         }
     }
 }

crates/wasmtime/src/runtime/component/values.rs

@@ -93,6 +93,7 @@ pub enum Val {
     Future(FutureAny),
     Stream(StreamAny),
     ErrorContext(ErrorContextAny),
+    FixedSizeList(Vec<Val>),
 }
 
 impl Val {
@@ -220,7 +221,11 @@ impl Val {
             InterfaceType::ErrorContext(_) => {
                 ErrorContext::linear_lift_from_flat(cx, ty, next(src))?.into_val()
             }
-            InterfaceType::FixedLengthList(_) => todo!(), // FIXME(#12279)
+            InterfaceType::FixedLengthList(i) => Val::FixedLengthList(
+                (0..cx.types[i].size)
+                    .map(|_| Self::lift(cx, cx.types[i].element, src))
+                    .collect::<Result<_>>()?,
+            ),
         })
     }
 
@@ -349,7 +354,20 @@ impl Val {
             InterfaceType::ErrorContext(_) => {
                 ErrorContext::linear_lift_from_memory(cx, ty, bytes)?.into_val()
             }
-            InterfaceType::FixedLengthList(_) => todo!(), // FIXME(#12279)
+            InterfaceType::FixedLengthList(i) => {
+                let element = cx.types[i].element.clone();
+                let abi = cx.types.canonical_abi(&element);
+                Val::Tuple(
+                    (0..cx.types[i].size)
+                        .map(|n| {
+                            let offset = abi.size32 * n;
+                            let offset = usize::try_from(offset).unwrap();
+                            let size = usize::try_from(abi.size32).unwrap();
+                            Val::load(cx, element, &bytes[offset..][..size])
+                        })
+                        .collect::<Result<_>>()?,
+                )
+            }
         })
     }
 
@@ -508,7 +526,17 @@ impl Val {
                 )
             }
             (InterfaceType::ErrorContext(_), _) => unexpected(ty, self),
-            (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)
+            (InterfaceType::FixedLengthList(ty), Val::FixedSizeList(values)) => {
+                let ty = &cx.types[ty];
+                if ty.size as usize != values.len() {
+                    bail!("expected vec of size {}, got {}", ty.size, values.len());
+                }
+                for value in values {
+                    value.lower(cx, ty.element, dst)?;
+                }
+                Ok(())
+            }
+            (InterfaceType::FixedSizeList(_), _) => unexpected(ty, self),
         }
     }
 
@@ -671,7 +699,18 @@ impl Val {
                 )
             }
             (InterfaceType::ErrorContext(_), _) => unexpected(ty, self),
-            (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)
+            (InterfaceType::FixedLengthList(ty), Val::FixedSizeList(values)) => {
+                let ty = &cx.types[ty];
+                if ty.size as usize != values.len() {
+                    bail!("expected {} types, got {}", ty.size, values.len());
+                }
+                let elemsize = cx.types.canonical_abi(&ty.element).size32 as usize;
+                for (n, value) in values.iter().enumerate() {
+                    value.store(cx, ty.element, elemsize * n)?;
+                }
+                Ok(())
+            }
+            (InterfaceType::FixedSizeList(_), _) => unexpected(ty, self),
         }
     }
 
@@ -703,6 +742,7 @@ impl Val {
             Val::Future(_) => "future",
             Val::Stream(_) => "stream",
             Val::ErrorContext(_) => "error-context",
+            Val::FixedSizeList(_) => "list<_, N>",
         }
     }
 
@@ -789,6 +829,8 @@ impl PartialEq for Val {
             (Self::Stream(_), _) => false,
             (Self::ErrorContext(l), Self::ErrorContext(r)) => l == r,
             (Self::ErrorContext(_), _) => false,
+            (Self::FixedSizeList(l), Self::FixedSizeList(r)) => l == r,
+            (Self::FixedSizeList(_), _) => false,
         }
     }
 }

crates/wasmtime/src/runtime/wave/component.rs

@@ -40,6 +40,7 @@ impl WasmType for component::Type {
             Self::Option(_) => WasmTypeKind::Option,
             Self::Result(_) => WasmTypeKind::Result,
             Self::Flags(_) => WasmTypeKind::Flags,
+            Self::FixedSizeList(_) => WasmTypeKind::FixedSizeList,
 
             Self::Own(_)
             | Self::Borrow(_)
@@ -144,6 +145,7 @@ impl WasmValue for component::Val {
             | Self::Future(_)
             | Self::ErrorContext(_)
             | Self::Map(_) => WasmTypeKind::Unsupported,
+            Self::FixedLengthList(_) => WasmTypeKind::FixedLengthList,
         }
     }