Merge pull request bytecodealliance#76 from dhil/wasmfx-merge

Merge with upstream. 

Notably this patch uses the latest wasmfx-tools-1.0.55 release.

Cargo.toml

@@ -92,6 +92,7 @@ serde_json = { workspace = true }
 walkdir = { workspace = true }
 test-programs-artifacts = { workspace = true }
 bytesize = "1.3.0"
+wit-component = { workspace = true }
 
 [target.'cfg(windows)'.dev-dependencies]
 windows-sys = { workspace = true, features = ["Win32_System_Memory"] }
@@ -119,6 +120,7 @@ members = [
   "examples/fib-debug/wasm",
   "examples/wasi/wasm",
   "examples/tokio/wasm",
+  "examples/component/wasm",
   "fuzz",
   "winch",
   "winch/codegen",
@@ -235,15 +237,15 @@ is-terminal = "0.4.0"
 wit-bindgen = { version = "0.15.0", default-features = false }
 
 # wasm-tools family:
-wasmparser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wat           = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wast          = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wasmprinter   = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wasm-encoder  = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wasm-smith    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wasm-mutate   = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wit-parser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
-wit-component = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.54.rev+1" }
+wasmparser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wat           = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wast          = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wasmprinter   = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wasm-encoder  = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wasm-smith    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wasm-mutate   = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wit-parser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
+wit-component = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.0.55" }
 
 # Non-Bytecode Alliance maintained dependencies:
 # --------------------------

cranelift/wasm/src/code_translator.rs

@@ -2503,7 +2503,42 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             state.push1(r);
         }
 
-        Operator::RefI31 | Operator::I31GetS | Operator::I31GetU => {
+        Operator::TryTable { .. } | Operator::ThrowRef => {
+            unimplemented!("exception operators not yet implemented")
+        }
+
+        Operator::RefI31
+        | Operator::I31GetS
+        | Operator::I31GetU
+        | Operator::RefEq
+        | Operator::RefTestNonNull { .. }
+        | Operator::RefTestNullable { .. }
+        | Operator::RefCastNonNull { .. }
+        | Operator::RefCastNullable { .. }
+        | Operator::BrOnCast { .. }
+        | Operator::BrOnCastFail { .. }
+        | Operator::AnyConvertExtern
+        | Operator::ExternConvertAny
+        | Operator::ArrayNew { .. }
+        | Operator::ArrayNewDefault { .. }
+        | Operator::ArrayNewFixed { .. }
+        | Operator::ArrayNewData { .. }
+        | Operator::ArrayNewElem { .. }
+        | Operator::ArrayGet { .. }
+        | Operator::ArrayGetU { .. }
+        | Operator::ArrayGetS { .. }
+        | Operator::ArraySet { .. }
+        | Operator::ArrayLen { .. }
+        | Operator::ArrayFill { .. }
+        | Operator::ArrayCopy { .. }
+        | Operator::ArrayInitData { .. }
+        | Operator::ArrayInitElem { .. }
+        | Operator::StructNew { .. }
+        | Operator::StructNewDefault { .. }
+        | Operator::StructGetS { .. }
+        | Operator::StructGetU { .. }
+        | Operator::StructSet { .. }
+        | Operator::StructGet { .. } => {
             unimplemented!("GC operators not yet implemented")
         }
 

cranelift/wasm/src/sections_translator.rs

@@ -409,6 +409,7 @@ pub fn parse_name_section<'data>(
             | wasmparser::Name::Memory(_)
             | wasmparser::Name::Element(_)
             | wasmparser::Name::Data(_)
+            | wasmparser::Name::Tag(_)
             | wasmparser::Name::Unknown { .. } => {}
         }
     }

cranelift/wasm/src/translation_utils.rs

@@ -4,7 +4,7 @@ use crate::WasmResult;
 use core::u32;
 use cranelift_codegen::ir;
 use cranelift_frontend::FunctionBuilder;
-use wasmparser::{FuncValidator, WasmFuncType, WasmModuleResources};
+use wasmparser::{FuncValidator, WasmModuleResources};
 use wasmtime_types::WasmType;
 
 /// Get the parameter and result types for the given Wasm blocktype.
@@ -30,11 +30,13 @@ where
         wasmparser::BlockType::FuncType(ty_index) => {
             let ty = validator
                 .resources()
-                .func_type_at(ty_index)
-                .expect("should be valid");
+                .sub_type_at(ty_index)
+                .expect("should be valid")
+                .unwrap_func();
+
             (
-                itertools::Either::Right(ty.inputs()),
-                itertools::Either::Right(ty.outputs()),
+                itertools::Either::Right(ty.params().iter().copied()),
+                itertools::Either::Right(ty.results().iter().copied()),
             )
         }
     });

cranelift/wasm/wasmtests/icall-simd.wat

@@ -3,5 +3,5 @@
   (func $foo (export "foo") (param i32) (param v128) (result v128)
     (call_indirect (type $ft) (local.get 1) (local.get 0))
   )
-  (table (;0;) 23 23 anyfunc)
+  (table (;0;) 23 23 funcref)
 )

cranelift/wasm/wasmtests/icall.wat

@@ -3,5 +3,5 @@
   (func $foo (export "foo") (param i32 f32) (result i32)
     (call_indirect (type $ft) (local.get 1) (local.get 0))
   )
-  (table (;0;) 23 23 anyfunc)
+  (table (;0;) 23 23 funcref)
 )

cranelift/wasm/wasmtests/unreachable_code.wat

@@ -72,6 +72,6 @@
     end
     drop
   )
-  (table (;0;) 16 anyfunc)
+  (table (;0;) 16 funcref)
   (elem (i32.const 0))
 )

crates/environ/src/module_environ.rs

@@ -892,6 +892,7 @@ and for re-adding support for interface types you can see this issue:
                 | wasmparser::Name::Memory(_)
                 | wasmparser::Name::Element(_)
                 | wasmparser::Name::Data(_)
+                | wasmparser::Name::Tag(_)
                 | wasmparser::Name::Unknown { .. } => {}
             }
         }

crates/fuzzing/src/generators/config.rs

@@ -47,7 +47,8 @@ impl Config {
         // Allow a memory to be generated, but don't let it get too large.
         // Additionally require the maximum size to guarantee that the growth
         // behavior is consistent across engines.
-        config.max_memory_pages = 10;
+        config.max_memory32_pages = 10;
+        config.max_memory64_pages = 10;
         config.memory_max_size_required = true;
 
         // If tables are generated make sure they don't get too large to avoid
@@ -339,19 +340,22 @@ impl<'a> Arbitrary<'a> for Config {
 
             // Ensure the pooling allocator can support the maximal size of
             // memory, picking the smaller of the two to win.
-            if cfg.max_memory_pages < pooling.memory_pages {
-                pooling.memory_pages = cfg.max_memory_pages;
-            } else {
-                cfg.max_memory_pages = pooling.memory_pages;
-            }
+            let min = cfg
+                .max_memory32_pages
+                .min(cfg.max_memory64_pages)
+                .min(pooling.memory_pages);
+            pooling.memory_pages = min;
+            cfg.max_memory32_pages = min;
+            cfg.max_memory64_pages = min;
 
             // If traps are disallowed then memories must have at least one page
             // of memory so if we still are only allowing 0 pages of memory then
             // increase that to one here.
             if cfg.disallow_traps {
                 if pooling.memory_pages == 0 {
                     pooling.memory_pages = 1;
-                    cfg.max_memory_pages = 1;
+                    cfg.max_memory32_pages = 1;
+                    cfg.max_memory64_pages = 1;
                 }
                 // .. additionally update tables
                 if pooling.table_elements == 0 {

crates/fuzzing/src/generators/module.rs

@@ -1,21 +1,20 @@
 //! Generate a Wasm module and the configuration for generating it.
 
 use arbitrary::{Arbitrary, Unstructured};
-use wasm_smith::SwarmConfig;
 
 /// Default module-level configuration for fuzzing Wasmtime.
 ///
-/// Internally this uses `wasm-smith`'s own `SwarmConfig` but we further refine
+/// Internally this uses `wasm-smith`'s own `Config` but we further refine
 /// the defaults here as well.
 #[derive(Debug, Clone)]
 pub struct ModuleConfig {
     #[allow(missing_docs)]
-    pub config: SwarmConfig,
+    pub config: wasm_smith::Config,
 }
 
 impl<'a> Arbitrary<'a> for ModuleConfig {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<ModuleConfig> {
-        let mut config = SwarmConfig::arbitrary(u)?;
+        let mut config = wasm_smith::Config::arbitrary(u)?;
 
         // Allow multi-memory but make it unlikely
         if u.ratio(1, 20)? {

crates/fuzzing/src/generators/single_inst_module.rs

@@ -314,11 +314,11 @@ static INSTRUCTIONS: &[SingleInstModule] = &[
     inst!(F32Ge, (f32, f32) -> i32),
     inst!(F64Ge, (f64, f64) -> i32),
     // Integer conversions ("to integer").
-    inst!(I32Extend8S, (i32) -> i32, |c| c.config.sign_extension_enabled),
-    inst!(I32Extend16S, (i32) -> i32, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend8S, (i64) -> i64, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend16S, (i64) -> i64, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend32S, (i64) -> i64, |c| c.config.sign_extension_enabled),
+    inst!(I32Extend8S, (i32) -> i32, |c| c.config.sign_extension_ops_enabled),
+    inst!(I32Extend16S, (i32) -> i32, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend8S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend16S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend32S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
     inst!(I32WrapI64, (i64) -> i32),
     inst!(I64ExtendI32S, (i32) -> i64),
     inst!(I64ExtendI32U, (i32) -> i64),

crates/test-programs/artifacts/build.rs

@@ -74,6 +74,7 @@ fn build_and_generate_tests() {
             s if s.starts_with("cli_") => "cli",
             s if s.starts_with("api_") => "api",
             s if s.starts_with("nn_") => "nn",
+            s if s.starts_with("piped_") => "piped",
             // If you're reading this because you hit this panic, either add it
             // to a test suite above or add a new "suite". The purpose of the
             // categorization above is to have a static assertion that tests

crates/test-programs/src/bin/piped_polling.rs

@@ -0,0 +1,51 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    match std::env::var("PIPED_SIDE")
+        .expect("piped tests require the PIPED_SIDE env var")
+        .as_str()
+    {
+        "PRODUCER" => producer(),
+        "CONSUMER" => consumer(),
+        side => panic!("unknown piped test side: {side}"),
+    }
+}
+
+fn producer() {
+    let out = stdout::get_stdout();
+    let out_pollable = out.subscribe();
+
+    for i in 1..100 {
+        let message = format!("{i}");
+        loop {
+            let available = out.check_write().unwrap() as usize;
+            if available >= message.len() {
+                break;
+            }
+
+            out_pollable.block();
+            assert!(out_pollable.ready());
+        }
+
+        out.write(message.as_bytes()).unwrap()
+    }
+
+    drop(out_pollable);
+}
+
+fn consumer() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+
+    for i in 1..100 {
+        let expected = format!("{i}");
+
+        stdin_pollable.block();
+        assert!(stdin_pollable.ready());
+
+        let bytes = stdin.read(expected.len() as u64).unwrap();
+        assert_eq!(&bytes, expected.as_bytes());
+    }
+
+    drop(stdin_pollable);
+}

crates/test-programs/src/bin/piped_simple.rs

@@ -0,0 +1,30 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    match std::env::var("PIPED_SIDE")
+        .expect("piped tests require the PIPED_SIDE env var")
+        .as_str()
+    {
+        "PRODUCER" => producer(),
+        "CONSUMER" => consumer(),
+        side => panic!("unknown piped test side: {side}"),
+    }
+}
+
+const CHUNK: &[u8] = &[b'a'; 50];
+
+fn producer() {
+    let out = stdout::get_stdout();
+    let n = out.check_write().unwrap() as usize;
+    assert!(n > CHUNK.len());
+    out.write(CHUNK).unwrap();
+}
+
+fn consumer() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+    stdin_pollable.block();
+    assert!(stdin_pollable.ready());
+    let bytes = stdin.read(CHUNK.len() as u64).unwrap();
+    assert_eq!(&bytes, CHUNK);
+}

crates/test-programs/src/bin/preview2_stream_pollable_correct.rs

@@ -1,11 +1,27 @@
-use test_programs::wasi::cli::stdin;
-use test_programs::wasi::io::streams;
+use test_programs::wasi::cli::{stdin, stdout};
 
 fn main() {
-    let stdin: streams::InputStream = stdin::get_stdin();
+    let stdin = stdin::get_stdin();
     let stdin_pollable = stdin.subscribe();
     stdin_pollable.block();
     assert!(stdin_pollable.ready(), "after blocking, pollable is ready");
     drop(stdin_pollable);
     drop(stdin);
+
+    // Pollables can be used many times over their lifetime
+    let stdout = stdout::get_stdout();
+    let stdout_pollable = stdout.subscribe();
+
+    let chunk = [b'a'; 50];
+    for _ in 1..10 {
+        stdout_pollable.block();
+        assert!(stdout_pollable.ready(), "after blocking, pollable is ready");
+
+        let n = stdout.check_write().unwrap() as usize;
+        assert!(n >= chunk.len());
+        stdout.write(&chunk).unwrap();
+    }
+
+    drop(stdout_pollable);
+    drop(stdout);
 }

crates/types/src/lib.rs

@@ -515,6 +515,7 @@ pub trait TypeConvert {
             wasmparser::HeapType::Concrete(i) => self.lookup_heap_type(i),
 
             wasmparser::HeapType::Any
+            | wasmparser::HeapType::Exn
             | wasmparser::HeapType::None
             | wasmparser::HeapType::NoExtern
             | wasmparser::HeapType::NoFunc

crates/wasmtime/src/engine/serialization.rs

@@ -223,6 +223,7 @@ impl Metadata<'_> {
             typed_continuations,
             gc,
             component_model_values,
+            component_model_nested_names,
 
             // Always on; we don't currently have knobs for these.
             mutable_global: _,
@@ -234,6 +235,7 @@ impl Metadata<'_> {
         assert!(!memory_control);
         assert!(!gc);
         assert!(!component_model_values);
+        assert!(!component_model_nested_names);
 
         Metadata {
             target: engine.compiler().triple().to_string(),

examples/CMakeLists.txt

@@ -62,6 +62,7 @@ create_target(wasi wasi/main.c)
 create_rust_wasm(fib-debug wasm32-unknown-unknown)
 create_rust_wasm(tokio wasm32-wasi)
 create_rust_wasm(wasi wasm32-wasi)
+create_rust_wasm(component wasm32-unknown-unknown)
 create_rust_test(epochs)
 create_rust_test(externref)
 create_rust_test(fib-debug)
@@ -77,3 +78,4 @@ create_rust_test(serialize)
 create_rust_test(threads)
 create_rust_test(wasi)
 create_rust_test(tokio wasmtime-wasi/tokio)
+create_rust_test(component)