A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Minimal implementation of fixed-length lists to enable wit-bindgen runtime tests (#10619)
Christof Petigcaf0f752f07a
diff --git a/crates/cli-flags/src/lib.rs b/crates/cli-flags/src/lib.rsindex 51fbd9b1ea..6cc61e6cfb 100644--- a/crates/cli-flags/src/lib.rs+++ b/crates/cli-flags/src/lib.rs@@ -409,6 +409,9 @@ wasmtime_option_group! {pub exceptions: Option<bool>,/// Whether or not any GC infrastructure in Wasmtime is enabled or not.pub gc_support: Option<bool>,+ /// Component model support for fixed-length lists: this corresponds+ /// to the 🔧 emoji in the component model specification+ pub component_model_fixed_length_lists: Option<bool>,}enum Wasm {@@ -1067,6 +1070,7 @@ impl CommonOptions {("component-model-async", component_model_async_stackful, wasm_component_model_async_stackful)("component-model-async", component_model_threading, wasm_component_model_threading)("component-model", component_model_error_context, wasm_component_model_error_context)+ ("component-model", component_model_fixed_length_lists, wasm_component_model_fixed_length_lists)("threads", threads, wasm_threads)("gc", gc, wasm_gc)("gc", reference_types, wasm_reference_types)diff --git a/crates/environ/src/component/types.rs b/crates/environ/src/component/types.rsindex 8db6b800c4..0f1a811a0d 100644--- a/crates/environ/src/component/types.rs+++ b/crates/environ/src/component/types.rs@@ -89,6 +89,8 @@ indices! {pub struct TypeResultIndex(u32);/// Index pointing to a list type in the component model.pub struct TypeListIndex(u32);+ /// Index pointing to a fixed size list type in the component model.+ pub struct TypeFixedLengthListIndex(u32);/// Index pointing to a future type in the component model.pub struct TypeFutureIndex(u32);@@ -296,6 +298,7 @@ pub struct ComponentTypes {pub(super) stream_tables: PrimaryMap<TypeStreamTableIndex, TypeStreamTable>,pub(super) error_context_tables:PrimaryMap<TypeComponentLocalErrorContextTableIndex, TypeErrorContextTable>,+ pub(super) fixed_length_lists: PrimaryMap<TypeFixedLengthListIndex, TypeFixedLengthList>,}impl TypeTrace for ComponentTypes {@@ -369,6 +372,7 @@ impl ComponentTypes {InterfaceType::Enum(i) => &self[*i].abi,InterfaceType::Option(i) => &self[*i].abi,InterfaceType::Result(i) => &self[*i].abi,+ InterfaceType::FixedLengthList(i) => &self[*i].abi,}}@@ -418,6 +422,7 @@ impl_index! {impl Index<TypeFutureTableIndex> for ComponentTypes { TypeFutureTable => future_tables }impl Index<TypeStreamTableIndex> for ComponentTypes { TypeStreamTable => stream_tables }impl Index<TypeComponentLocalErrorContextTableIndex> for ComponentTypes { TypeErrorContextTable => error_context_tables }+ impl Index<TypeFixedLengthListIndex> for ComponentTypes { TypeFixedLengthList => fixed_length_lists }}// Additionally forward anything that can index `ModuleTypes` to `ModuleTypes`@@ -595,6 +600,7 @@ pub enum InterfaceType {Future(TypeFutureTableIndex),Stream(TypeStreamTableIndex),ErrorContext(TypeComponentLocalErrorContextTableIndex),+ FixedLengthList(TypeFixedLengthListIndex),}/// Bye information about a type in the canonical ABI, with metadata for both@@ -1175,6 +1181,17 @@ pub struct TypeList {pub element: InterfaceType,}+/// Shape of a "fixed size list" interface type.+#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]+pub struct TypeFixedLengthList {+ /// The element type of the list.+ pub element: InterfaceType,+ /// The fixed length of the list.+ pub size: u32,+ /// Byte information about this type in the canonical ABI.+ pub abi: CanonicalAbiInfo,+}+/// Maximum number of flat types, for either params or results.pub const MAX_FLAT_TYPES: usize = if MAX_FLAT_PARAMS > MAX_FLAT_RESULTS {MAX_FLAT_PARAMSdiff --git a/crates/environ/src/component/types_builder.rs b/crates/environ/src/component/types_builder.rsindex 090081388a..ddfe291b08 100644--- a/crates/environ/src/component/types_builder.rs+++ b/crates/environ/src/component/types_builder.rs@@ -50,6 +50,7 @@ pub struct ComponentTypesBuilder {future_tables: HashMap<TypeFutureTable, TypeFutureTableIndex>,stream_tables: HashMap<TypeStreamTable, TypeStreamTableIndex>,error_context_tables: HashMap<TypeErrorContextTable, TypeComponentLocalErrorContextTableIndex>,+ fixed_length_lists: HashMap<TypeFixedLengthList, TypeFixedLengthListIndex>,component_types: ComponentTypes,module_types: ModuleTypesBuilder,@@ -118,6 +119,7 @@ impl ComponentTypesBuilder {type_info: TypeInformationCache::default(),resources: ResourcesBuilder::default(),abstract_resources: 0,+ fixed_length_lists: HashMap::default(),}}@@ -456,8 +458,8 @@ impl ComponentTypesBuilder {ComponentDefinedType::Stream(ty) => {InterfaceType::Stream(self.stream_table_type(types, ty)?)}- ComponentDefinedType::FixedSizeList(..) => {- bail!("support not implemented for fixed-size-lists");+ ComponentDefinedType::FixedSizeList(ty, size) => {+ InterfaceType::FixedLengthList(self.fixed_length_list_type(types, ty, *size)?)}ComponentDefinedType::Map(..) => {bail!("support not implemented for map type");@@ -575,6 +577,34 @@ impl ComponentTypesBuilder {self.add_tuple_type(TypeTuple { types, abi })}+ fn fixed_length_list_type(+ &mut self,+ types: TypesRef<'_>,+ ty: &ComponentValType,+ size: u32,+ ) -> Result<TypeFixedLengthListIndex> {+ assert_eq!(types.id(), self.module_types.validator_id());+ let element = self.valtype(types, ty)?;+ Ok(self.new_fixed_length_list_type(element, size))+ }++ pub(crate) fn new_fixed_length_list_type(+ &mut self,+ element: InterfaceType,+ size: u32,+ ) -> TypeFixedLengthListIndex {+ let element_abi = self.component_types.canonical_abi(&element);+ let mut abi = element_abi.clone();+ // this assumes that size32 is already rounded up to alignment+ abi.size32 = element_abi.size32.saturating_mul(size);+ abi.size64 = element_abi.size64.saturating_mul(size);+ abi.flat_count = element_abi+ .flat_count+ .zip(u8::try_from(size).ok())+ .and_then(|(flat_count, size)| flat_count.checked_mul(size));+ self.add_fixed_length_list_type(TypeFixedLengthList { element, size, abi })+ }+fn flags_type(&mut self, flags: &IndexSet<KebabString>) -> TypeFlagsIndex {let flags = TypeFlags {names: flags.iter().map(|s| s.to_string()).collect(),@@ -691,6 +721,14 @@ impl ComponentTypesBuilder {intern_and_fill_flat_types!(self, tuples, ty)}+ /// Interns a new tuple type within this type information.+ pub fn add_fixed_length_list_type(+ &mut self,+ ty: TypeFixedLengthList,+ ) -> TypeFixedLengthListIndex {+ intern_and_fill_flat_types!(self, fixed_length_lists, ty)+ }+/// Interns a new variant type within this type information.pub fn add_variant_type(&mut self, ty: TypeVariant) -> TypeVariantIndex {intern_and_fill_flat_types!(self, variants, ty)@@ -826,6 +864,7 @@ impl ComponentTypesBuilder {InterfaceType::Enum(i) => &self.type_info.enums[*i],InterfaceType::Option(i) => &self.type_info.options[*i],InterfaceType::Result(i) => &self.type_info.results[*i],+ InterfaceType::FixedLengthList(i) => &self.type_info.fixed_length_lists[*i],}}}@@ -935,6 +974,7 @@ struct TypeInformationCache {options: PrimaryMap<TypeOptionIndex, TypeInformation>,results: PrimaryMap<TypeResultIndex, TypeInformation>,lists: PrimaryMap<TypeListIndex, TypeInformation>,+ fixed_length_lists: PrimaryMap<TypeFixedLengthListIndex, TypeInformation>,}struct TypeInformation {@@ -1084,6 +1124,24 @@ impl TypeInformation {self.build_record(ty.types.iter().map(|t| types.type_information(t)));}+ fn fixed_length_lists(&mut self, types: &ComponentTypesBuilder, ty: &TypeFixedLengthList) {+ let element_info = types.type_information(&ty.element);+ self.depth = 1 + element_info.depth;+ self.has_borrow = element_info.has_borrow;+ match element_info.flat.as_flat_types() {+ Some(types) => {+ 'outer: for _ in 0..ty.size {+ for (t32, t64) in types.memory32.iter().zip(types.memory64) {+ if !self.flat.push(*t32, *t64) {+ break 'outer;+ }+ }+ }+ }+ None => self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap(),+ }+ }+fn enums(&mut self, _types: &ComponentTypesBuilder, _ty: &TypeEnum) {self.depth = 1;self.flat.push(FlatType::I32, FlatType::I32);diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rsindex f75c30ccf3..2df0b1e6ba 100644--- a/crates/environ/src/fact/trampoline.rs+++ b/crates/environ/src/fact/trampoline.rs@@ -19,9 +19,10 @@ use crate::component::{CanonicalAbiInfo, ComponentTypesBuilder, FLAG_MAY_ENTER, FLAG_MAY_LEAVE, FixedEncoding as FE,FlatType, InterfaceType, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT,PREPARE_ASYNC_WITH_RESULT, START_FLAG_ASYNC_CALLEE, StringEncoding, Transcode,- TypeComponentLocalErrorContextTableIndex, TypeEnumIndex, TypeFlagsIndex, TypeFutureTableIndex,- TypeListIndex, TypeOptionIndex, TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex,- TypeStreamTableIndex, TypeTupleIndex, TypeVariantIndex, VariantInfo,+ TypeComponentLocalErrorContextTableIndex, TypeEnumIndex, TypeFixedLengthListIndex,+ TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex, TypeOptionIndex, TypeRecordIndex,+ TypeResourceTableIndex, TypeResultIndex, TypeStreamTableIndex, TypeTupleIndex,+ TypeVariantIndex, VariantInfo,};use crate::fact::signature::Signature;use crate::fact::transcode::Transcoder;@@ -1126,6 +1127,7 @@ impl<'a, 'b> Compiler<'a, 'b> {| InterfaceType::Future(_)| InterfaceType::Stream(_)| InterfaceType::ErrorContext(_) => 1,+ InterfaceType::FixedLengthList(i) => self.types[*i].size as usize,};match self.fuel.checked_sub(cost) {@@ -1165,6 +1167,9 @@ impl<'a, 'b> Compiler<'a, 'b> {InterfaceType::ErrorContext(t) => {self.translate_error_context(*t, src, dst_ty, dst)}+ InterfaceType::FixedLengthList(t) => {+ self.translate_fixed_length_list(*t, src, dst_ty, dst);+ }}}@@ -2858,6 +2863,113 @@ impl<'a, 'b> Compiler<'a, 'b> {}}+ fn translate_fixed_length_list(+ &mut self,+ src_ty: TypeFixedLengthListIndex,+ src: &Source<'_>,+ dst_ty: &InterfaceType,+ dst: &Destination,+ ) {+ let src_ty = &self.types[src_ty];+ let dst_ty = match dst_ty {+ InterfaceType::FixedLengthList(t) => &self.types[*t],+ _ => panic!("expected a fixed size list"),+ };++ // TODO: subtyping+ assert_eq!(src_ty.size, dst_ty.size);++ match (&src, &dst) {+ // Generate custom code for memory to memory copy+ (Source::Memory(src_mem), Destination::Memory(dst_mem)) => {+ let src_mem_opts = match &src_mem.opts.data_model {+ DataModel::Gc {} => todo!("CM+GC"),+ DataModel::LinearMemory(opts) => opts,+ };+ let dst_mem_opts = match &dst_mem.opts.data_model {+ DataModel::Gc {} => todo!("CM+GC"),+ DataModel::LinearMemory(opts) => opts,+ };+ let src_element_bytes = self.types.size_align(src_mem_opts, &src_ty.element).0;+ let dst_element_bytes = self.types.size_align(dst_mem_opts, &dst_ty.element).0;+ assert_ne!(src_element_bytes, 0);+ assert_ne!(dst_element_bytes, 0);++ // because data is stored in-line, we assume that source and destination memory have been validated upstream++ self.instruction(LocalGet(src_mem.addr.idx));+ if src_mem.offset != 0 {+ self.ptr_uconst(src_mem_opts, src_mem.offset);+ self.ptr_add(src_mem_opts);+ }+ let cur_src_ptr = self.local_set_new_tmp(src_mem_opts.ptr());+ self.instruction(LocalGet(dst_mem.addr.idx));+ if dst_mem.offset != 0 {+ self.ptr_uconst(dst_mem_opts, dst_mem.offset);+ self.ptr_add(dst_mem_opts);+ }+ let cur_dst_ptr = self.local_set_new_tmp(dst_mem_opts.ptr());++ self.instruction(I32Const(src_ty.size as i32));+ let remaining = self.local_set_new_tmp(ValType::I32);++ self.instruction(Loop(BlockType::Empty));++ // Translate the next element in the list+ let element_src = Source::Memory(Memory {+ opts: src_mem.opts,+ offset: 0,+ addr: TempLocal::new(cur_src_ptr.idx, cur_src_ptr.ty),+ });+ let element_dst = Destination::Memory(Memory {+ opts: dst_mem.opts,+ offset: 0,+ addr: TempLocal::new(cur_dst_ptr.idx, cur_dst_ptr.ty),+ });+ self.translate(&src_ty.element, &element_src, &dst_ty.element, &element_dst);++ // Update the two loop pointers+ self.instruction(LocalGet(cur_src_ptr.idx));+ self.ptr_uconst(src_mem_opts, src_element_bytes);+ self.ptr_add(src_mem_opts);+ self.instruction(LocalSet(cur_src_ptr.idx));+ self.instruction(LocalGet(cur_dst_ptr.idx));+ self.ptr_uconst(dst_mem_opts, dst_element_bytes);+ self.ptr_add(dst_mem_opts);+ self.instruction(LocalSet(cur_dst_ptr.idx));++ // Update the remaining count, falling through to break out if it's zero+ // now.+ self.instruction(LocalGet(remaining.idx));+ self.ptr_iconst(src_mem_opts, -1);+ self.ptr_add(src_mem_opts);+ self.instruction(LocalTee(remaining.idx));+ self.ptr_br_if(src_mem_opts, 0);+ self.instruction(End); // end of loop++ self.free_temp_local(cur_dst_ptr);+ self.free_temp_local(cur_src_ptr);+ self.free_temp_local(remaining);+ return;+ }+ // for the non-memory-to-memory case fall back to using generic tuple translation+ (_, _) => {+ // Assumes that the number of elements are small enough for this unrolling+ assert!(+ src_ty.size as usize <= MAX_FLAT_PARAMS+ && dst_ty.size as usize <= MAX_FLAT_PARAMS+ );+ let srcs =+ src.record_field_srcs(self.types, (0..src_ty.size).map(|_| src_ty.element));+ let dsts =+ dst.record_field_dsts(self.types, (0..dst_ty.size).map(|_| dst_ty.element));+ for (src, dst) in srcs.zip(dsts) {+ self.translate(&src_ty.element, &src, &dst_ty.element, &dst);+ }+ }+ }+ }+fn translate_variant(&mut self,src_ty: TypeVariantIndex,diff --git a/crates/fuzzing/src/generators/config.rs b/crates/fuzzing/src/generators/config.rsindex d4782a77c5..1663e963c5 100644--- a/crates/fuzzing/src/generators/config.rs+++ b/crates/fuzzing/src/generators/config.rs@@ -140,6 +140,7 @@ impl Config {component_model_threading,component_model_error_context,component_model_gc,+ component_model_fixed_length_lists,simd,exceptions,legacy_exceptions: _,@@ -165,6 +166,8 @@ impl Config {self.module_config.component_model_error_context =component_model_error_context.unwrap_or(false);self.module_config.component_model_gc = component_model_gc.unwrap_or(false);+ self.module_config.component_model_fixed_length_lists =+ component_model_fixed_length_lists.unwrap_or(false);// Enable/disable proposals that wasm-smith has knobs for which will be// read when creating `wasmtime::Config`.@@ -290,6 +293,8 @@ impl Config {cfg.wasm.component_model_error_context =Some(self.module_config.component_model_error_context);cfg.wasm.component_model_gc = Some(self.module_config.component_model_gc);+ cfg.wasm.component_model_fixed_length_lists =+ Some(self.module_config.component_model_fixed_length_lists);cfg.wasm.custom_page_sizes = Some(self.module_config.config.custom_page_sizes_enabled);cfg.wasm.epoch_interruption = Some(self.wasmtime.epoch_interruption);cfg.wasm.extended_const = Some(self.module_config.config.extended_const_enabled);diff --git a/crates/fuzzing/src/generators/module.rs b/crates/fuzzing/src/generators/module.rsindex 58e10cf903..db89d56b5b 100644--- a/crates/fuzzing/src/generators/module.rs+++ b/crates/fuzzing/src/generators/module.rs@@ -22,6 +22,7 @@ pub struct ModuleConfig {pub component_model_threading: bool,pub component_model_error_context: bool,pub component_model_gc: bool,+ pub component_model_fixed_length_lists: bool,pub legacy_exceptions: bool,pub shared_memory: bool,}@@ -79,6 +80,7 @@ impl<'a> Arbitrary<'a> for ModuleConfig {component_model_threading: false,component_model_error_context: false,component_model_gc: false,+ component_model_fixed_length_lists: false,legacy_exceptions: false,shared_memory: false,function_references_enabled: config.gc_enabled,diff --git a/crates/test-util/src/wasmtime_wast.rs b/crates/test-util/src/wasmtime_wast.rsindex a20f011b12..d9a22a8684 100644--- a/crates/test-util/src/wasmtime_wast.rs+++ b/crates/test-util/src/wasmtime_wast.rs@@ -43,6 +43,7 @@ pub fn apply_test_config(config: &mut Config, test_config: &wast::TestConfig) {component_model_threading,component_model_error_context,component_model_gc,+ component_model_fixed_length_lists,nan_canonicalization,simd,exceptions,@@ -72,6 +73,7 @@ pub fn apply_test_config(config: &mut Config, test_config: &wast::TestConfig) {let component_model_threading = component_model_threading.unwrap_or(false);let component_model_error_context = component_model_error_context.unwrap_or(false);let component_model_gc = component_model_gc.unwrap_or(false);+ let component_model_fixed_length_lists = component_model_fixed_length_lists.unwrap_or(false);let nan_canonicalization = nan_canonicalization.unwrap_or(false);let relaxed_simd = relaxed_simd.unwrap_or(false);let legacy_exceptions = legacy_exceptions.unwrap_or(false);@@ -111,6 +113,7 @@ pub fn apply_test_config(config: &mut Config, test_config: &wast::TestConfig) {.wasm_component_model_threading(component_model_threading).wasm_component_model_error_context(component_model_error_context).wasm_component_model_gc(component_model_gc)+ .wasm_component_model_fixed_length_lists(component_model_fixed_length_lists).wasm_exceptions(exceptions).wasm_stack_switching(stack_switching).cranelift_nan_canonicalization(nan_canonicalization);diff --git a/crates/test-util/src/wast.rs b/crates/test-util/src/wast.rsindex c07dda1f8b..5408ee33fe 100644--- a/crates/test-util/src/wast.rs+++ b/crates/test-util/src/wast.rs@@ -268,6 +268,7 @@ macro_rules! foreach_config_option {component_model_threadingcomponent_model_error_contextcomponent_model_gc+ component_model_fixed_length_listssimdgc_typesexceptionsdiff --git a/crates/wasmtime/src/config.rs b/crates/wasmtime/src/config.rsindex d4b4485d9d..ac68506481 100644--- a/crates/wasmtime/src/config.rs+++ b/crates/wasmtime/src/config.rs@@ -1296,6 +1296,16 @@ impl Config {self}+ /// This corresponds to the 🔧 emoji in the component model specification.+ ///+ /// Please note that Wasmtime's support for this feature is _very_+ /// incomplete.+ #[cfg(feature = "component-model")]+ pub fn wasm_component_model_fixed_length_lists(&mut self, enable: bool) -> &mut Self {+ self.wasm_features(WasmFeatures::CM_FIXED_SIZE_LIST, enable);+ self+ }+/// Configures whether the [Exception-handling proposal][proposal] is enabled or not.////// [proposal]: https://github.com/WebAssembly/exception-handling@@ -2264,7 +2274,8 @@ impl Config {| WasmFeatures::CM_ASYNC_BUILTINS| WasmFeatures::CM_THREADING| WasmFeatures::CM_ERROR_CONTEXT- | WasmFeatures::CM_GC;+ | WasmFeatures::CM_GC+ | WasmFeatures::CM_FIXED_SIZE_LIST;#[allow(unused_mut, reason = "easier to avoid #[cfg]")]let mut unsupported = !features_known_to_wasmtime;diff --git a/crates/wasmtime/src/runtime/component/func/typed.rs b/crates/wasmtime/src/runtime/component/func/typed.rsindex cb466d5bd4..62ade6e71b 100644--- a/crates/wasmtime/src/runtime/component/func/typed.rs+++ b/crates/wasmtime/src/runtime/component/func/typed.rs@@ -2929,6 +2929,7 @@ pub fn desc(ty: &InterfaceType) -> &'static str {InterfaceType::Future(_) => "future",InterfaceType::Stream(_) => "stream",InterfaceType::ErrorContext(_) => "error-context",+ InterfaceType::FixedLengthList(_) => "list<_, N>",}}diff --git a/crates/wasmtime/src/runtime/component/types.rs b/crates/wasmtime/src/runtime/component/types.rsindex 948fc8e51f..63aff29672 100644--- a/crates/wasmtime/src/runtime/component/types.rs+++ b/crates/wasmtime/src/runtime/component/types.rs@@ -158,6 +158,7 @@ impl TypeChecker<'_> {(InterfaceType::Stream(_), _) => false,(InterfaceType::ErrorContext(_), InterfaceType::ErrorContext(_)) => true,(InterfaceType::ErrorContext(_), _) => false,+ (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)}}@@ -855,6 +856,7 @@ 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)}}diff --git a/crates/wasmtime/src/runtime/component/values.rs b/crates/wasmtime/src/runtime/component/values.rsindex d0b1d0209d..695cb140a8 100644--- a/crates/wasmtime/src/runtime/component/values.rs+++ b/crates/wasmtime/src/runtime/component/values.rs@@ -215,6 +215,7 @@ impl Val {InterfaceType::ErrorContext(_) => {ErrorContext::linear_lift_from_flat(cx, ty, next(src))?.into_val()}+ InterfaceType::FixedLengthList(_) => todo!(), // FIXME(#12279)})}@@ -341,6 +342,7 @@ impl Val {InterfaceType::ErrorContext(_) => {ErrorContext::linear_lift_from_memory(cx, ty, bytes)?.into_val()}+ InterfaceType::FixedLengthList(_) => todo!(), // FIXME(#12279)})}@@ -491,6 +493,7 @@ impl Val {)}(InterfaceType::ErrorContext(_), _) => unexpected(ty, self),+ (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)}}@@ -644,6 +647,7 @@ impl Val {)}(InterfaceType::ErrorContext(_), _) => unexpected(ty, self),+ (InterfaceType::FixedLengthList(_), _) => todo!(), // FIXME(#12279)}}diff --git a/tests/misc_testsuite/component-model/fixed_length_lists.wast b/tests/misc_testsuite/component-model/fixed_length_lists.wastnew file mode 100644index 0000000000..9e1d76563b--- /dev/null+++ b/tests/misc_testsuite/component-model/fixed_length_lists.wast@@ -0,0 +1,422 @@+;;! multi_memory = true+;;! component_model_fixed_length_lists = true++;; This contains two components which exercise fixed-size-list+;; types. The first acts as a roundtrip, the second calls the first+;; and compares the results.++;; As this was written with C++ and wit-bindgen the functions+;; are not expected to be easily human readable.++;; The exported function run() from the second component+;; calls nested-roundtrip([[1, 2], [3, 4]], [[-1, -2], [-3, -4]])+;; from the first module and compares the resulting tuple with a+;; concatenation of the inputs.++;; Every mismatch increases the return value by 1.++(component+ (component (;0;)+ (type $ty-test:fixed-size-lists/to-test (;0;)+ (instance+ (type (;0;) (list u32 2))+ (type (;1;) (list 0 2))+ (type (;2;) (list s32 2))+ (type (;3;) (list 2 2))+ (type (;4;) (tuple 1 3))+ (type (;5;) (func (param "a" 1) (param "b" 3) (result 4)))+ (export (;0;) "nested-roundtrip" (func (type 5)))+ )+ )+ (import "test:fixed-size-lists/to-test" (instance $test:fixed-size-lists/to-test (;0;) (type $ty-test:fixed-size-lists/to-test)))+ (core module $main (;0;)+ (type (;0;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32)))+ (type (;1;) (func (result i32)))+ (import "test:fixed-size-lists/to-test" "nested-roundtrip" (func (;0;) (type 0)))+ (memory (;0;) 2)+ (global (;0;) (mut i32) (i32.const 67232))+ (export "memory" (memory 0))+ ;; test runner, pass the values from the address 1024ff in registers+ ;; to the roundtrip function and+ ;; return the number of non-matching results+ (export "run" (func 1))+ (func (;1;) (type 1) (result i32)+ (local i32 i32 i32 i32 i32 i32 i32 i32 i32)+ (global.set 0+ (local.tee 0+ (i32.add+ (global.get 0)+ (i32.const -64))))+ (i64.store+ (i32.add+ (local.tee 1+ (i32.add+ (local.get 0)+ (i32.const 16)))+ (i32.const 8))+ (i64.load align=4+ (i32.const 1032)))+ (i64.store+ (i32.add+ (local.get 0)+ (i32.const 8))+ (i64.load align=4+ (i32.const 1048)))+ (i64.store offset=16+ (local.get 0)+ (i64.load align=4+ (i32.const 1024)))+ (i64.store+ (local.get 0)+ (i64.load align=4+ (i32.const 1040)))+ (global.set 0+ (local.tee 2+ (i32.sub+ (global.get 0)+ (i32.const 32))))+ (call 0+ (i32.load+ (local.get 1))+ (i32.load offset=4+ (local.get 1))+ (i32.load offset=8+ (local.get 1))+ (i32.load offset=12+ (local.get 1))+ (i32.load+ (local.get 0))+ (i32.load offset=4+ (local.get 0))+ (i32.load offset=8+ (local.get 0))+ (i32.load offset=12+ (local.get 0))+ (local.get 2))+ (i64.store offset=24 align=4+ (local.tee 1+ (i32.add+ (local.get 0)+ (i32.const 32)))+ (i64.load offset=24+ (local.get 2)))+ (i64.store offset=16 align=4+ (local.get 1)+ (i64.load offset=16+ (local.get 2)))+ (i64.store offset=8 align=4+ (local.get 1)+ (i64.load offset=8+ (local.get 2)))+ (i64.store align=4+ (local.get 1)+ (i64.load+ (local.get 2)))+ (global.set 0+ (i32.add+ (local.get 2)+ (i32.const 32)))+ (local.set 2+ (i32.load offset=48+ (local.get 0)))+ (i32.add+ (i32.add+ (i32.add+ (i32.add+ (i32.add+ (i32.add+ (i32.add+ (i32.ne+ (i32.load offset=32+ (local.get 0))+ (local.set 3+ (i32.load offset=36+ (local.get 0)))+ (local.set 4+ (i32.load offset=52+ (local.get 0)))+ (local.set 5+ (i32.load offset=40+ (local.get 0)))+ (local.set 6+ (i32.load offset=56+ (local.get 0)))+ (local.set 7+ (i32.load offset=44+ (local.get 0)))+ (local.set 8+ (i32.load offset=60+ (local.get 0)))+ ;; here the output values are checked+ (global.set 0+ (i32.sub+ (local.get 0)+ (i32.const -64)))+ (i32.const 1))+ (i32.ne+ (local.get 2)+ (i32.const -1)))+ (i32.ne+ (local.get 3)+ (i32.const 2)))+ (i32.ne+ (local.get 4)+ (i32.const -2)))+ (i32.ne+ (local.get 5)+ (i32.const 3)))+ (i32.ne+ (local.get 6)+ (i32.const -3)))+ (i32.ne+ (local.get 7)+ (i32.const 4)))+ (i32.ne+ (local.get 8)+ (i32.const -4)))+ )+ ;; here are the input values+ (data (;0;) (i32.const 1024) "\01\00\00\00\02\00\00\00\03\00\00\00\04\00\00\00\ff\ff\ff\ff\fe\ff\ff\ff\fd\ff\ff\ff\fc\ff\ff\ff")+ (data (;1;) (i32.const 1056) "\ff\ff\ff\ff\00\00\02")+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (core module $wit-component-shim-module (;1;)+ (type (;0;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32)))+ (table (;0;) 1 1 funcref)+ (export "0" (func 0))+ (export "$imports" (table 0))+ (func (;0;) (type 0) (param i32 i32 i32 i32 i32 i32 i32 i32 i32)+ (call_indirect (type 0)+ (local.get 0)+ (local.get 1)+ (local.get 2)+ (local.get 3)+ (local.get 4)+ (local.get 5)+ (local.get 6)+ (local.get 7)+ (local.get 8)+ (i32.const 0))+ )+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (core module $wit-component-fixup (;2;)+ (type (;0;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32)))+ (import "" "0" (func (;0;) (type 0)))+ (import "" "$imports" (table (;0;) 1 1 funcref))+ (elem (;0;) (i32.const 0) func 0)+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (core instance $wit-component-shim-instance (;0;) (instantiate $wit-component-shim-module))+ (alias core export $wit-component-shim-instance "0" (core func $indirect-test:fixed-size-lists/to-test-nested-roundtrip (;0;)))+ (core instance $test:fixed-size-lists/to-test (;1;)+ (export "nested-roundtrip" (func $indirect-test:fixed-size-lists/to-test-nested-roundtrip))+ )+ (core instance $main (;2;) (instantiate $main+ (with "test:fixed-size-lists/to-test" (instance $test:fixed-size-lists/to-test))+ )+ )+ (alias core export $main "memory" (core memory $memory (;0;)))+ (alias core export $wit-component-shim-instance "$imports" (core table $"shim table" (;0;)))+ (alias export $test:fixed-size-lists/to-test "nested-roundtrip" (func $nested-roundtrip (;0;)))+ (core func $"#core-func1 indirect-test:fixed-size-lists/to-test-nested-roundtrip" (@name "indirect-test:fixed-size-lists/to-test-nested-roundtrip") (;1;) (canon lower (func $nested-roundtrip) (memory $memory)))+ (core instance $fixup-args (;3;)+ (export "$imports" (table $"shim table"))+ (export "0" (func $"#core-func1 indirect-test:fixed-size-lists/to-test-nested-roundtrip"))+ )+ (core instance $fixup (;4;) (instantiate $wit-component-fixup+ (with "" (instance $fixup-args))+ )+ )+ (type (;1;) (func (result u32)))+ (alias core export $main "run" (core func $run (;2;)))+ (func $run (;1;) (type 1) (canon lift (core func $run)))+ (export $"#func2 run" (@name "run") (;2;) "run" (func $run))+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (component (;1;)+ (core module $main (;0;)+ (type (;0;) (func (param i32 i32 i32 i32 i32 i32 i32 i32) (result i32)))+ (memory (;0;) 2)+ (global (;0;) (mut i32) (i32.const 67248))+ (export "memory" (memory 0))+ (export "test:fixed-size-lists/to-test#nested-roundtrip" (func 0))+ ;; This is an obfuscated store from the stack to address 1056,+ ;; which is then returned+ (func (;0;) (type 0) (param i32 i32 i32 i32 i32 i32 i32 i32) (result i32)+ (local i32 i32 i64 i64)+ (global.set 0+ (local.tee 8+ (i32.sub+ (global.get 0)+ (i32.const 96))))+ (i32.store+ (local.tee 9+ (i32.add+ (local.get 8)+ (i32.const 56)))+ (local.get 2))+ (i32.store+ (local.tee 2+ (i32.add+ (local.get 8)+ (i32.const 40)))+ (local.get 6))+ (i32.store offset=60+ (local.get 8)+ (local.get 3))+ (i64.store+ (local.tee 6+ (i32.add+ (local.tee 3+ (i32.add+ (local.get 8)+ (i32.const 16)))+ (i32.const 8)))+ (i64.load+ (local.get 9)))+ (i32.store offset=44+ (local.get 8)+ (local.get 7))+ (i64.store+ (local.tee 7+ (i32.add+ (local.get 8)+ (i32.const 8)))+ (i64.load+ (local.get 2)))+ (i64.store offset=48+ (local.get 8)+ (local.tee 10+ (i64.or+ (i64.extend_i32_u+ (local.get 0))+ (i64.shl+ (i64.extend_i32_u+ (local.get 1))+ (i64.const 32)))))+ (i64.store offset=32+ (local.get 8)+ (local.tee 11+ (i64.or+ (i64.extend_i32_u+ (local.get 4))+ (i64.shl+ (i64.extend_i32_u+ (local.get 5))+ (i64.const 32)))))+ (i64.store offset=16+ (local.get 8)+ (local.get 10))+ (i64.store+ (local.get 8)+ (local.get 11))+ (i64.store align=4+ (local.tee 0+ (i32.sub+ (local.get 8)+ (i32.const -64)))+ (i64.load align=4+ (local.get 3)))+ (i64.store offset=16 align=4+ (local.get 0)+ (i64.load align=4+ (local.get 8)))+ (i64.store align=4+ (local.tee 1+ (i32.add+ (local.get 0)+ (i32.const 8)))+ (i64.load align=4+ (local.get 6)))+ (i64.store align=4+ (i32.add+ (local.get 0)+ (i32.const 24))+ (i64.load align=4+ (local.get 7)))+ (i64.store+ (i32.const 1064)+ (i64.load align=4+ (local.get 1)))+ (i64.store+ (i32.const 1056)+ (i64.load offset=64 align=4+ (local.get 8)))+ (i64.store+ (i32.const 1072)+ (i64.load offset=80 align=4+ (local.get 8)))+ (i64.store+ (i32.const 1080)+ (i64.load align=4+ (i32.add+ (local.get 8)+ (i32.const 88))))+ (global.set 0+ (i32.add+ (local.get 8)+ (i32.const 96)))+ (i32.const 1056)+ )+ (data (;0;) (i32.const 1024) "\ff\ff\ff\ff\00\00\02")+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (core instance $main (;0;) (instantiate $main))+ (alias core export $main "memory" (core memory $memory (;0;)))+ (type (;0;) (list u32 2))+ (type (;1;) (list 0 2))+ (type (;2;) (list s32 2))+ (type (;3;) (list 2 2))+ (type (;4;) (tuple 1 3))+ (type (;5;) (func (param "a" 1) (param "b" 3) (result 4)))+ (alias core export $main "test:fixed-size-lists/to-test#nested-roundtrip" (core func $test:fixed-size-lists/to-test#nested-roundtrip (;0;)))+ (func $nested-roundtrip (;0;) (type 5) (canon lift (core func $test:fixed-size-lists/to-test#nested-roundtrip) (memory $memory)))+ (component $test:fixed-size-lists/to-test-shim-component (;0;)+ (type (;0;) (list u32 2))+ (type (;1;) (list 0 2))+ (type (;2;) (list s32 2))+ (type (;3;) (list 2 2))+ (type (;4;) (tuple 1 3))+ (type (;5;) (func (param "a" 1) (param "b" 3) (result 4)))+ (import "import-func-nested-roundtrip" (func (;0;) (type 5)))+ (type (;6;) (list u32 2))+ (type (;7;) (list 6 2))+ (type (;8;) (list s32 2))+ (type (;9;) (list 8 2))+ (type (;10;) (tuple 7 9))+ (type (;11;) (func (param "a" 7) (param "b" 9) (result 10)))+ (export (;1;) "nested-roundtrip" (func 0) (func (type 11)))+ )+ (instance $test:fixed-size-lists/to-test-shim-instance (;0;) (instantiate $test:fixed-size-lists/to-test-shim-component+ (with "import-func-nested-roundtrip" (func $nested-roundtrip))+ )+ )+ (export $test:fixed-size-lists/to-test (;1;) "test:fixed-size-lists/to-test" (instance $test:fixed-size-lists/to-test-shim-instance))+ (@producers+ (processed-by "wit-component" "0.243.0")+ )+ )+ (instance (;0;) (instantiate 1))+ (alias export 0 "test:fixed-size-lists/to-test" (instance (;1;)))+ (instance (;2;) (instantiate 0+ (with "test:fixed-size-lists/to-test" (instance 1))+ )+ )+ (alias export 2 "run" (func (;0;)))+ (export (;1;) "run" (func 0))+)++;; call run, it will return the number of mismatches in the test+(assert_return (invoke "run")+ (u32.const 0))