A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Lift/lower refactors inspired by `map<K, V>` (#12753)
Alex Crichtona0d5346d2215
diff --git a/crates/environ/src/collections/hash_map.rs b/crates/environ/src/collections/hash_map.rsindex 6f3a674ef9..d83d67d966 100644--- a/crates/environ/src/collections/hash_map.rs+++ b/crates/environ/src/collections/hash_map.rs@@ -252,3 +252,9 @@ impl<K, V, S> IntoIterator for TryHashMap<K, V, S> {self.inner.into_iter()}}++impl<K, V, S> From<TryHashMap<K, V, S>> for inner::HashMap<K, V, S> {+ fn from(map: TryHashMap<K, V, S>) -> Self {+ map.inner+ }+}diff --git a/crates/wasmtime/src/runtime/component/func/typed.rs b/crates/wasmtime/src/runtime/component/func/typed.rsindex 88de546856..360d82a975 100644--- a/crates/wasmtime/src/runtime/component/func/typed.rs+++ b/crates/wasmtime/src/runtime/component/func/typed.rs@@ -2,7 +2,6 @@ use crate::component::Instance;use crate::component::func::{Func, LiftContext, LowerContext};use crate::component::matching::InstanceType;use crate::component::storage::{storage_as_slice, storage_as_slice_mut};-#[cfg(not(feature = "std"))]use crate::hash_map::HashMap;use crate::prelude::*;use crate::{AsContextMut, StoreContext, StoreContextMut, ValRaw};@@ -15,15 +14,12 @@ use core::mem::{self, MaybeUninit};use core::str;use wasmtime_environ::component::{CanonicalAbiInfo, ComponentTypes, InterfaceType, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,- OptionsIndex, StringEncoding, VariantInfo,+ OptionsIndex, StringEncoding, TypeMap, VariantInfo,};#[cfg(feature = "component-model-async")]use crate::component::concurrent::{self, AsAccessor, PreparedCall};-#[cfg(feature = "std")]-use wasmtime_environ::collections::TryHashMap;-/// A statically-typed version of [`Func`] which takes `Params` as input and/// returns `Return`.///@@ -1440,6 +1436,49 @@ unsafe impl Lift for char {}}+fn lift_pointer_pair_from_flat(+ cx: &mut LiftContext<'_>,+ src: &[ValRaw; 2],+) -> Result<(usize, usize)> {+ // FIXME(#4311): needs memory64 treatment+ let _ = cx; // this will be needed for memory64 in the future+ let ptr = src[0].get_u32();+ let len = src[1].get_u32();+ Ok((usize::try_from(ptr)?, usize::try_from(len)?))+}++fn lift_pointer_pair_from_memory(cx: &mut LiftContext<'_>, bytes: &[u8]) -> Result<(usize, usize)> {+ // FIXME(#4311): needs memory64 treatment+ let _ = cx; // this will be needed for memory64 in the future+ let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());+ let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());+ Ok((usize::try_from(ptr)?, usize::try_from(len)?))+}++fn lower_pointer_pair_to_flat<T>(+ cx: &mut LowerContext<T>,+ dst: &mut MaybeUninit<[ValRaw; 2]>,+ ptr: usize,+ len: usize,+) {+ // See "WRITEPTR64" above for why this is always storing a 64-bit+ // integer.+ let _ = cx; // this will eventually be needed for memory64 information.+ map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));+ map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));+}++fn lower_pointer_pair_to_memory<T>(+ cx: &mut LowerContext<T>,+ offset: usize,+ ptr: usize,+ len: usize,+) {+ // FIXME(#4311): needs memory64 handling+ *cx.get(offset + 0) = u32::try_from(ptr).unwrap().to_le_bytes();+ *cx.get(offset + 4) = u32::try_from(len).unwrap().to_le_bytes();+}+// FIXME(#4311): these probably need different constants for memory64const UTF16_TAG: usize = 1 << 31;const MAX_STRING_BYTE_LENGTH: usize = (1 << 31) - 1;@@ -1468,10 +1507,7 @@ unsafe impl Lower for str {) -> Result<()> {debug_assert!(matches!(ty, InterfaceType::String));let (ptr, len) = lower_string(cx, self)?;- // See "WRITEPTR64" above for why this is always storing a 64-bit- // integer.- map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));- map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));+ lower_pointer_pair_to_flat(cx, dst, ptr, len);Ok(())}@@ -1484,9 +1520,7 @@ unsafe impl Lower for str {debug_assert!(matches!(ty, InterfaceType::String));debug_assert!(offset % (Self::ALIGN32 as usize) == 0);let (ptr, len) = lower_string(cx, self)?;- // FIXME(#4311): needs memory64 handling- *cx.get(offset + 0) = u32::try_from(ptr).unwrap().to_le_bytes();- *cx.get(offset + 4) = u32::try_from(len).unwrap().to_le_bytes();+ lower_pointer_pair_to_memory(cx, offset, ptr, len);Ok(())}}@@ -1768,10 +1802,7 @@ unsafe impl Lift for WasmStr {src: &Self::Lower,) -> Result<Self> {debug_assert!(matches!(ty, InterfaceType::String));- // FIXME(#4311): needs memory64 treatment- let ptr = src[0].get_u32();- let len = src[1].get_u32();- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let (ptr, len) = lift_pointer_pair_from_flat(cx, src)?;WasmStr::new(ptr, len, cx)}@@ -1783,10 +1814,7 @@ unsafe impl Lift for WasmStr {) -> Result<Self> {debug_assert!(matches!(ty, InterfaceType::String));debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let (ptr, len) = lift_pointer_pair_from_memory(cx, bytes)?;WasmStr::new(ptr, len, cx)}}@@ -1822,10 +1850,7 @@ where_ => bad_type_info(),};let (ptr, len) = lower_list(cx, elem, self)?;- // See "WRITEPTR64" above for why this is always storing a 64-bit- // integer.- map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));- map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));+ lower_pointer_pair_to_flat(cx, dst, ptr, len);Ok(())}@@ -1841,8 +1866,7 @@ where};debug_assert!(offset % (Self::ALIGN32 as usize) == 0);let (ptr, len) = lower_list(cx, elem, self)?;- *cx.get(offset + 0) = u32::try_from(ptr).unwrap().to_le_bytes();- *cx.get(offset + 4) = u32::try_from(len).unwrap().to_le_bytes();+ lower_pointer_pair_to_memory(cx, offset, ptr, len);Ok(())}}@@ -2064,10 +2088,7 @@ unsafe impl<T: Lift> Lift for WasmList<T> {InterfaceType::List(i) => cx.types[i].element,_ => bad_type_info(),};- // FIXME(#4311): needs memory64 treatment- let ptr = src[0].get_u32();- let len = src[1].get_u32();- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let (ptr, len) = lift_pointer_pair_from_flat(cx, src)?;WasmList::new(ptr, len, cx, elem)}@@ -2081,10 +2102,7 @@ unsafe impl<T: Lift> Lift for WasmList<T> {_ => bad_type_info(),};debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let (ptr, len) = lift_pointer_pair_from_memory(cx, bytes)?;WasmList::new(ptr, len, cx, elem)}}@@ -2095,48 +2113,13 @@ unsafe impl<T: Lift> Lift for WasmList<T> {// Maps are represented as `list<tuple<K, V>>` in the canonical ABI, so the// lowered form is a (pointer, length) pair just like lists.-fn typecheck_map<K, V>(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()>-where- K: ComponentType,- V: ComponentType,-{+fn map_abi<'a>(ty: InterfaceType, types: &'a ComponentTypes) -> &'a TypeMap {match ty {- InterfaceType::Map(t) => {- let map_ty = &types.types[*t];- K::typecheck(&map_ty.key, types)?;- V::typecheck(&map_ty.value, types)?;- Ok(())- }- other => bail!("expected `map` found `{}`", desc(other)),- }-}--#[derive(Copy, Clone)]-struct MapAbi32 {- key_ty: InterfaceType,- value_ty: InterfaceType,- tuple_size: usize,- tuple_align: u32,- value_offset: usize,-}--fn map_abi32(ty: InterfaceType, types: &ComponentTypes) -> MapAbi32 {- match ty {- InterfaceType::Map(i) => {- let m = &types[i];- MapAbi32 {- key_ty: m.key,- value_ty: m.value,- tuple_size: usize::try_from(m.entry_abi.size32).unwrap(),- tuple_align: m.entry_abi.align32,- value_offset: usize::try_from(m.value_offset32).unwrap(),- }- }+ InterfaceType::Map(i) => &types[i],_ => bad_type_info(),}}-#[cfg(not(feature = "std"))]unsafe impl<K, V> ComponentType for HashMap<K, V>whereK: ComponentType,@@ -2147,11 +2130,10 @@ whereconst ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {- typecheck_map::<K, V>(ty, types)+ TryHashMap::<K, V>::typecheck(ty, types)}}-#[cfg(not(feature = "std"))]unsafe impl<K, V> Lower for HashMap<K, V>whereK: Lower,@@ -2163,7 +2145,10 @@ wherety: InterfaceType,dst: &mut MaybeUninit<[ValRaw; 2]>,) -> Result<()> {- linear_lower_map_to_flat(cx, ty, self.len(), self.iter(), dst)+ let map = map_abi(ty, &cx.types);+ let (ptr, len) = lower_map_iter(cx, map, self.len(), self.iter())?;+ lower_pointer_pair_to_flat(cx, dst, ptr, len);+ Ok(())}fn linear_lower_to_memory<U>(@@ -2172,81 +2157,14 @@ wherety: InterfaceType,offset: usize,) -> Result<()> {- linear_lower_map_to_memory(cx, ty, self.len(), self.iter(), offset)- }-}--fn lower_map_iter<'a, K, V, U>(- cx: &mut LowerContext<'_, U>,- map: MapAbi32,- len: usize,- iter: impl Iterator<Item = (&'a K, &'a V)>,-) -> Result<(usize, usize)>-where- K: Lower + 'a,- V: Lower + 'a,-{- let size = len- .checked_mul(map.tuple_size)- .ok_or_else(|| format_err!("size overflow copying a map"))?;- let ptr = cx.realloc(0, 0, map.tuple_align, size)?;-- let mut entry_offset = ptr;- for (key, value) in iter {- // Keys are the first field in each entry tuple.- <K as Lower>::linear_lower_to_memory(key, cx, map.key_ty, entry_offset)?;- // Values start at the precomputed value offset within the tuple.- <V as Lower>::linear_lower_to_memory(- value,- cx,- map.value_ty,- entry_offset + map.value_offset,- )?;- entry_offset += map.tuple_size;+ let map = map_abi(ty, &cx.types);+ debug_assert!(offset % (CanonicalAbiInfo::POINTER_PAIR.align32 as usize) == 0);+ let (ptr, len) = lower_map_iter(cx, map, self.len(), self.iter())?;+ lower_pointer_pair_to_memory(cx, offset, ptr, len);+ Ok(())}-- Ok((ptr, len))-}--fn linear_lower_map_to_flat<'a, K, V, U>(- cx: &mut LowerContext<'_, U>,- ty: InterfaceType,- len: usize,- iter: impl Iterator<Item = (&'a K, &'a V)>,- dst: &mut MaybeUninit<[ValRaw; 2]>,-) -> Result<()>-where- K: Lower + 'a,- V: Lower + 'a,-{- let map = map_abi32(ty, &cx.types);- let (ptr, len) = lower_map_iter(cx, map, len, iter)?;- // See "WRITEPTR64" above for why this is always storing a 64-bit integer.- map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));- map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));- Ok(())-}--fn linear_lower_map_to_memory<'a, K, V, U>(- cx: &mut LowerContext<'_, U>,- ty: InterfaceType,- len: usize,- iter: impl Iterator<Item = (&'a K, &'a V)>,- offset: usize,-) -> Result<()>-where- K: Lower + 'a,- V: Lower + 'a,-{- let map = map_abi32(ty, &cx.types);- debug_assert!(offset % (CanonicalAbiInfo::POINTER_PAIR.align32 as usize) == 0);- let (ptr, len) = lower_map_iter(cx, map, len, iter)?;- *cx.get(offset + 0) = u32::try_from(ptr).unwrap().to_le_bytes();- *cx.get(offset + 4) = u32::try_from(len).unwrap().to_le_bytes();- Ok(())}-#[cfg(not(feature = "std"))]unsafe impl<K, V> Lift for HashMap<K, V>whereK: Lift + Eq + Hash,@@ -2257,12 +2175,7 @@ wherety: InterfaceType,src: &Self::Lower,) -> Result<Self> {- let map = map_abi32(ty, &cx.types);- // FIXME(#4311): needs memory64 treatment- let ptr = src[0].get_u32();- let len = src[1].get_u32();- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);- lift_map(cx, map, ptr, len)+ Ok(TryHashMap::<K, V>::linear_lift_from_flat(cx, ty, src)?.into())}fn linear_lift_from_memory(@@ -2270,150 +2183,43 @@ wherety: InterfaceType,bytes: &[u8],) -> Result<Self> {- let map = map_abi32(ty, &cx.types);- debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);- lift_map(cx, map, ptr, len)- }-}--/// Shared helper that validates a map's memory region and lifts each-/// (key, value) pair, forwarding them to `insert`.-fn lift_map_pairs<K, V>(- cx: &mut LiftContext<'_>,- map: MapAbi32,- ptr: usize,- len: usize,- mut insert: impl FnMut(K, V) -> Result<()>,-) -> Result<()>-where- K: Lift,- V: Lift,-{- match len- .checked_mul(map.tuple_size)- .and_then(|total| ptr.checked_add(total))- {- Some(n) if n <= cx.memory().len() => {}- _ => bail!("map pointer/length out of bounds of memory"),- }- if ptr % (map.tuple_align as usize) != 0 {- bail!("map pointer is not aligned");+ Ok(TryHashMap::<K, V>::linear_lift_from_memory(cx, ty, bytes)?.into())}-- for i in 0..len {- let entry_base = ptr + (i * map.tuple_size);-- let key_bytes = &cx.memory()[entry_base..][..K::SIZE32];- let key = K::linear_lift_from_memory(cx, map.key_ty, key_bytes)?;-- let value_bytes = &cx.memory()[entry_base + map.value_offset..][..V::SIZE32];- let value = V::linear_lift_from_memory(cx, map.value_ty, value_bytes)?;-- insert(key, value)?;- }-- Ok(())}-#[cfg(not(feature = "std"))]-fn lift_map<K, V>(- cx: &mut LiftContext<'_>,- map: MapAbi32,- ptr: usize,+fn lower_map_iter<'a, K, V, U>(+ cx: &mut LowerContext<'_, U>,+ map: &TypeMap,len: usize,-) -> Result<HashMap<K, V>>-where- K: Lift + Eq + Hash,- V: Lift,-{- let mut result = HashMap::with_capacity(len);- lift_map_pairs(cx, map, ptr, len, |k, v| {- result.insert(k, v);- Ok(())- })?;- Ok(result)-}--// =============================================================================-// std::collections::HashMap<K, V> support for component model `map<K, V>`--#[cfg(feature = "std")]-unsafe impl<K, V> ComponentType for std::collections::HashMap<K, V>-where- K: ComponentType,- V: ComponentType,-{- type Lower = [ValRaw; 2];-- const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;-- fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {- typecheck_map::<K, V>(ty, types)- }-}--#[cfg(feature = "std")]-unsafe impl<K, V> Lower for std::collections::HashMap<K, V>+ iter: impl Iterator<Item = (&'a K, &'a V)>,+) -> Result<(usize, usize)>where- K: Lower,- V: Lower,+ K: Lower + 'a,+ V: Lower + 'a,{- fn linear_lower_to_flat<U>(- &self,- cx: &mut LowerContext<'_, U>,- ty: InterfaceType,- dst: &mut MaybeUninit<[ValRaw; 2]>,- ) -> Result<()> {- linear_lower_map_to_flat(cx, ty, self.len(), self.iter(), dst)- }-- fn linear_lower_to_memory<U>(- &self,- cx: &mut LowerContext<'_, U>,- ty: InterfaceType,- offset: usize,- ) -> Result<()> {- linear_lower_map_to_memory(cx, ty, self.len(), self.iter(), offset)- }-}+ let size = len+ .checked_mul(usize::try_from(map.entry_abi.size32)?)+ .ok_or_else(|| format_err!("size overflow copying a map"))?;+ let ptr = cx.realloc(0, 0, map.entry_abi.align32, size)?;-#[cfg(feature = "std")]-unsafe impl<K, V> Lift for std::collections::HashMap<K, V>-where- K: Lift + Eq + Hash,- V: Lift,-{- fn linear_lift_from_flat(- cx: &mut LiftContext<'_>,- ty: InterfaceType,- src: &Self::Lower,- ) -> Result<Self> {- let try_map =- <wasmtime_environ::collections::TryHashMap<K, V> as Lift>::linear_lift_from_flat(- cx, ty, src,- )?;- Ok(try_map.into_iter().collect())+ let mut entry_offset = ptr;+ for (key, value) in iter {+ // Keys are the first field in each entry tuple.+ <K as Lower>::linear_lower_to_memory(key, cx, map.key, entry_offset)?;+ // Values start at the precomputed value offset within the tuple.+ <V as Lower>::linear_lower_to_memory(+ value,+ cx,+ map.value,+ entry_offset + usize::try_from(map.value_offset32)?,+ )?;+ entry_offset += usize::try_from(map.entry_abi.size32)?;}- fn linear_lift_from_memory(- cx: &mut LiftContext<'_>,- ty: InterfaceType,- bytes: &[u8],- ) -> Result<Self> {- let try_map =- <wasmtime_environ::collections::TryHashMap<K, V> as Lift>::linear_lift_from_memory(- cx, ty, bytes,- )?;- Ok(try_map.into_iter().collect())- }+ Ok((ptr, len))}-#[cfg(feature = "std")]-unsafe impl<K, V> ComponentType for wasmtime_environ::collections::TryHashMap<K, V>+unsafe impl<K, V> ComponentType for TryHashMap<K, V>whereK: ComponentType,V: ComponentType,@@ -2423,12 +2229,19 @@ whereconst ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {- typecheck_map::<K, V>(ty, types)+ match ty {+ InterfaceType::Map(t) => {+ let map_ty = &types.types[*t];+ K::typecheck(&map_ty.key, types)?;+ V::typecheck(&map_ty.value, types)?;+ Ok(())+ }+ other => bail!("expected `map` found `{}`", desc(other)),+ }}}-#[cfg(feature = "std")]-unsafe impl<K, V> Lower for wasmtime_environ::collections::TryHashMap<K, V>+unsafe impl<K, V> Lower for TryHashMap<K, V>whereK: Lower,V: Lower,@@ -2439,7 +2252,10 @@ wherety: InterfaceType,dst: &mut MaybeUninit<[ValRaw; 2]>,) -> Result<()> {- linear_lower_map_to_flat(cx, ty, self.len(), self.iter(), dst)+ let map = map_abi(ty, &cx.types);+ let (ptr, len) = lower_map_iter(cx, map, self.len(), self.iter())?;+ lower_pointer_pair_to_flat(cx, dst, ptr, len);+ Ok(())}fn linear_lower_to_memory<U>(@@ -2448,12 +2264,15 @@ wherety: InterfaceType,offset: usize,) -> Result<()> {- linear_lower_map_to_memory(cx, ty, self.len(), self.iter(), offset)+ let map = map_abi(ty, &cx.types);+ debug_assert!(offset % (CanonicalAbiInfo::POINTER_PAIR.align32 as usize) == 0);+ let (ptr, len) = lower_map_iter(cx, map, self.len(), self.iter())?;+ lower_pointer_pair_to_memory(cx, offset, ptr, len);+ Ok(())}}-#[cfg(feature = "std")]-unsafe impl<K, V> Lift for wasmtime_environ::collections::TryHashMap<K, V>+unsafe impl<K, V> Lift for TryHashMap<K, V>whereK: Lift + Eq + Hash,V: Lift,@@ -2463,11 +2282,8 @@ wherety: InterfaceType,src: &Self::Lower,) -> Result<Self> {- let map = map_abi32(ty, &cx.types);- // FIXME(#4311): needs memory64 treatment- let ptr = src[0].get_u32();- let len = src[1].get_u32();- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let map = map_abi(ty, &cx.types);+ let (ptr, len) = lift_pointer_pair_from_flat(cx, src)?;lift_try_map(cx, map, ptr, len)}@@ -2476,20 +2292,16 @@ wherety: InterfaceType,bytes: &[u8],) -> Result<Self> {- let map = map_abi32(ty, &cx.types);+ let map = map_abi(ty, &cx.types);debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());- let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);+ let (ptr, len) = lift_pointer_pair_from_memory(cx, bytes)?;lift_try_map(cx, map, ptr, len)}}-#[cfg(feature = "std")]fn lift_try_map<K, V>(cx: &mut LiftContext<'_>,- map: MapAbi32,+ map: &TypeMap,ptr: usize,len: usize,) -> Result<TryHashMap<K, V>>@@ -2498,9 +2310,31 @@ whereV: Lift,{let mut result = TryHashMap::with_capacity(len)?;- lift_map_pairs(cx, map, ptr, len, |k, v| {- result.insert(k, v).map(drop).map_err(Into::into)- })?;++ match len+ .checked_mul(usize::try_from(map.entry_abi.size32)?)+ .and_then(|total| ptr.checked_add(total))+ {+ Some(n) if n <= cx.memory().len() => cx.consume_fuel(n - ptr)?,+ _ => bail!("map pointer/length out of bounds of memory"),+ }+ if ptr % (map.entry_abi.align32 as usize) != 0 {+ bail!("map pointer is not aligned");+ }++ for i in 0..len {+ let entry_base = ptr + (i * usize::try_from(map.entry_abi.size32)?);++ let key_bytes = &cx.memory()[entry_base..][..K::SIZE32];+ let key = K::linear_lift_from_memory(cx, map.key, key_bytes)?;++ let value_bytes =+ &cx.memory()[entry_base + usize::try_from(map.value_offset32)?..][..V::SIZE32];+ let value = V::linear_lift_from_memory(cx, map.value, value_bytes)?;++ result.insert(key, value)?;+ }+Ok(result)}diff --git a/crates/wasmtime/src/runtime/component/values.rs b/crates/wasmtime/src/runtime/component/values.rsindex fd154b8f2b..6a5e8bba9e 100644--- a/crates/wasmtime/src/runtime/component/values.rs+++ b/crates/wasmtime/src/runtime/component/values.rs@@ -124,16 +124,11 @@ impl Val {&[*next(src), *next(src)],)?),InterfaceType::List(i) => {- // FIXME(#4311): needs memory64 treatment- let ptr = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;- let len = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;+ let (ptr, len) = lift_flat_pointer_pair(cx, src)?;load_list(cx, i, ptr, len)?}InterfaceType::Map(i) => {- // FIXME(#4311): needs memory64 treatment- // Maps are represented as list<tuple<k, v>> in canonical ABI- let ptr = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;- let len = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;+ let (ptr, len) = lift_flat_pointer_pair(cx, src)?;load_map(cx, i, ptr, len)?}InterfaceType::Record(i) => Val::Record(@@ -249,15 +244,11 @@ impl Val {Val::Resource(ResourceAny::linear_lift_from_memory(cx, ty, bytes)?)}InterfaceType::List(i) => {- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap()) as usize;+ let (ptr, len) = load_flat_pointer_pair(bytes);load_list(cx, i, ptr, len)?}InterfaceType::Map(i) => {- // FIXME(#4311): needs memory64 treatment- let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;- let len = u32::from_le_bytes(bytes[4..].try_into().unwrap()) as usize;+ let (ptr, len) = load_flat_pointer_pair(bytes);load_map(cx, i, ptr, len)?}@@ -945,6 +936,22 @@ impl GenericVariant<'_> {}}+fn lift_flat_pointer_pair(+ cx: &mut LiftContext<'_>,+ src: &mut Iter<'_, ValRaw>,+) -> Result<(usize, usize)> {+ // FIXME(#4311): needs memory64 treatment+ let ptr = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;+ let len = u32::linear_lift_from_flat(cx, InterfaceType::U32, next(src))? as usize;+ Ok((ptr, len))+}++fn load_flat_pointer_pair(bytes: &[u8]) -> (usize, usize) {+ let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;+ let len = u32::from_le_bytes(bytes[4..].try_into().unwrap()) as usize;+ (ptr, len)+}+fn load_list(cx: &mut LiftContext<'_>, ty: TypeListIndex, ptr: usize, len: usize) -> Result<Val> {let elem = cx.types[ty].element;let abi = cx.types.canonical_abi(&elem);@@ -994,7 +1001,7 @@ fn load_map(cx: &mut LiftContext<'_>, ty: TypeMapIndex, ptr: usize, len: usize).checked_mul(tuple_size).and_then(|len| ptr.checked_add(len)){- Some(n) if n <= cx.memory().len() => {}+ Some(n) if n <= cx.memory().len() => cx.consume_fuel(n - ptr)?,_ => bail!("map pointer/length out of bounds of memory"),}if ptr % usize::try_from(tuple_alignment)? != 0 {