Merge pull request #5 from dhil/wasmfx-merge

Merge with upstream

Author: dhil

Cargo.lock

@@ -26,7 +26,6 @@ bitflags = "2.3.3"
 heck = { version = "0.4", features = ["unicode"] }
 pulldown-cmark = { version = "0.9", default-features = false }
 clap = { version = "4.3.19", features = ["derive"] }
-env_logger = "0.10.0"
 indexmap = "2.0.0"
 
 wasmparser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "wasmfx-tools-1.201.0+rev.1" }
@@ -80,8 +79,8 @@ csharp-mono = ['csharp']
 
 [dev-dependencies]
 heck = { workspace = true }
-wasmtime = { version = "17.0.0", features = ['component-model'] }
-wasmtime-wasi =  { version = "17.0.0" }
+wasmtime = { version = "19.0.0", features = ['component-model'] }
+wasmtime-wasi =  { version = "19.0.0" }
 test-artifacts = { path = 'crates/test-rust-wasm/artifacts' }
 wit-parser = { workspace = true }
 wasmparser = { workspace = true }

Cargo.toml

@@ -22,6 +22,10 @@ struct C {
     return_pointer_area_align: usize,
     names: Ns,
     needs_string: bool,
+    needs_union_int32_float: bool,
+    needs_union_float_int32: bool,
+    needs_union_int64_double: bool,
+    needs_union_double_int64: bool,
     prim_names: HashSet<String>,
     world: String,
     sizes: SizeAlign,
@@ -331,7 +335,7 @@ impl WorldGenerator for C {
                 self.src.h_helpers,
                 "
                    // Transfers ownership of `s` into the string `ret`
-                   void {snake}_string_set({snake}_string_t *ret, {c_string_ty} *s);
+                   void {snake}_string_set({snake}_string_t *ret, const {c_string_ty} *s);
 
                    // Creates a copy of the input nul-terminate string `s` and
                    // stores it into the component model string `ret`.
@@ -345,14 +349,14 @@ impl WorldGenerator for C {
             uwrite!(
                 self.src.c_helpers,
                 "
-                   void {snake}_string_set({snake}_string_t *ret, {c_string_ty} *s) {{
+                   void {snake}_string_set({snake}_string_t *ret, const {c_string_ty} *s) {{
                        ret->ptr = ({ty}*) s;
                        ret->len = {strlen};
                    }}
 
                    void {snake}_string_dup({snake}_string_t *ret, const {c_string_ty} *s) {{
                        ret->len = {strlen};
-                       ret->ptr = cabi_realloc(NULL, 0, {size}, ret->len * {size});
+                       ret->ptr = ({ty}*) cabi_realloc(NULL, 0, {size}, ret->len * {size});
                        memcpy(ret->ptr, s, ret->len * {size});
                    }}
 
@@ -366,6 +370,30 @@ impl WorldGenerator for C {
                ",
             );
         }
+        if self.needs_union_int32_float {
+            uwriteln!(
+                self.src.c_helpers,
+                "\nunion int32_float {{ int32_t a; float b; }};"
+            );
+        }
+        if self.needs_union_float_int32 {
+            uwriteln!(
+                self.src.c_helpers,
+                "\nunion float_int32 {{ float a; int32_t b; }};"
+            );
+        }
+        if self.needs_union_int64_double {
+            uwriteln!(
+                self.src.c_helpers,
+                "\nunion int64_double {{ int64_t a; double b; }};"
+            );
+        }
+        if self.needs_union_double_int64 {
+            uwriteln!(
+                self.src.c_helpers,
+                "\nunion double_int64 {{ double a; int64_t b; }};"
+            );
+        }
         let version = env!("CARGO_PKG_VERSION");
         let mut h_str = wit_bindgen_core::Source::default();
 
@@ -570,6 +598,51 @@ impl C {
         self.type_names.retain(|k, _| live_import_types.contains(k));
         self.resources.retain(|k, _| live_import_types.contains(k));
     }
+
+    fn perform_cast(&mut self, op: &str, cast: &Bitcast) -> String {
+        match cast {
+            Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
+                self.needs_union_int32_float = true;
+                format!("((union int32_float){{ (int32_t) {} }}).b", op)
+            }
+            Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
+                self.needs_union_float_int32 = true;
+                format!("((union float_int32){{ {} }}).b", op)
+            }
+            Bitcast::I64ToF64 => {
+                self.needs_union_int64_double = true;
+                format!("((union int64_double){{ (int64_t) {} }}).b", op)
+            }
+            Bitcast::F64ToI64 => {
+                self.needs_union_double_int64 = true;
+                format!("((union double_int64){{ {} }}).b", op)
+            }
+            Bitcast::I32ToI64 | Bitcast::LToI64 | Bitcast::PToP64 => {
+                format!("(int64_t) {}", op)
+            }
+            Bitcast::I64ToI32 | Bitcast::I64ToL => {
+                format!("(int32_t) {}", op)
+            }
+            // P64 is currently represented as int64_t, so no conversion is needed.
+            Bitcast::I64ToP64 | Bitcast::P64ToI64 => {
+                format!("{}", op)
+            }
+            Bitcast::P64ToP | Bitcast::I32ToP | Bitcast::LToP => {
+                format!("(uint8_t *) {}", op)
+            }
+
+            // Cast to uintptr_t to avoid implicit pointer-to-int conversions.
+            Bitcast::PToI32 | Bitcast::PToL => format!("(uintptr_t) {}", op),
+
+            Bitcast::I32ToL | Bitcast::LToI32 | Bitcast::None => op.to_string(),
+
+            Bitcast::Sequence(sequence) => {
+                let [first, second] = &**sequence;
+                let inner = self.perform_cast(op, first);
+                self.perform_cast(&inner, second)
+            }
+        }
+    }
 }
 
 pub fn imported_types_used_by_exported_interfaces(
@@ -2068,7 +2141,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
     fn load_ext(&mut self, ty: &str, offset: i32, operands: &[String], results: &mut Vec<String>) {
         self.load(ty, offset, operands, results);
         let result = results.pop().unwrap();
-        results.push(format!("(int32_t) ({})", result));
+        results.push(format!("(int32_t) {}", result));
     }
 
     fn store(&mut self, ty: &str, offset: i32, operands: &[String]) {
@@ -2208,7 +2281,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
             Instruction::Bitcasts { casts } => {
                 for (cast, op) in casts.iter().zip(operands) {
-                    let op = perform_cast(op, cast);
+                    let op = self.gen.gen.perform_cast(op, cast);
                     results.push(op);
                 }
             }
@@ -2223,11 +2296,12 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     results.push(format!("({}).{}", op, to_c_ident(&f.name)));
                 }
             }
-            Instruction::RecordLift { ty, .. } => {
+            Instruction::RecordLift { ty, record, .. } => {
                 let name = self.gen.gen.type_name(&Type::Id(*ty));
                 let mut result = format!("({}) {{\n", name);
-                for op in operands {
-                    uwriteln!(result, "{},", op);
+                for (field, op) in record.fields.iter().zip(operands.iter()) {
+                    let field_ty = self.gen.gen.type_name(&field.ty);
+                    uwriteln!(result, "({}) {},", field_ty, op);
                 }
                 result.push_str("}");
                 results.push(result);
@@ -2239,11 +2313,12 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     results.push(format!("({}).f{}", op, i));
                 }
             }
-            Instruction::TupleLift { ty, .. } => {
+            Instruction::TupleLift { ty, tuple, .. } => {
                 let name = self.gen.gen.type_name(&Type::Id(*ty));
                 let mut result = format!("({}) {{\n", name);
-                for op in operands {
-                    uwriteln!(result, "{},", op);
+                for (ty, op) in tuple.types.iter().zip(operands.iter()) {
+                    let ty = self.gen.gen.type_name(&ty);
+                    uwriteln!(result, "({}) {},", ty, op);
                 }
                 result.push_str("}");
                 results.push(result);
@@ -2943,46 +3018,6 @@ impl Bindgen for FunctionBindgen<'_, '_> {
     }
 }
 
-fn perform_cast(op: &str, cast: &Bitcast) -> String {
-    match cast {
-        Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
-            format!("((union {{ int32_t a; float b; }}){{ {} }}).b", op)
-        }
-        Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
-            format!("((union {{ float a; int32_t b; }}){{ {} }}).b", op)
-        }
-        Bitcast::I64ToF64 => {
-            format!("((union {{ int64_t a; double b; }}){{ {} }}).b", op)
-        }
-        Bitcast::F64ToI64 => {
-            format!("((union {{ double a; int64_t b; }}){{ {} }}).b", op)
-        }
-        Bitcast::I32ToI64 | Bitcast::LToI64 | Bitcast::PToP64 => {
-            format!("(int64_t) {}", op)
-        }
-        Bitcast::I64ToI32 | Bitcast::I64ToL => {
-            format!("(int32_t) {}", op)
-        }
-        // P64 is currently represented as int64_t, so no conversion is needed.
-        Bitcast::I64ToP64 | Bitcast::P64ToI64 => {
-            format!("{}", op)
-        }
-        Bitcast::P64ToP | Bitcast::I32ToP | Bitcast::LToP => {
-            format!("(uint8_t *) {}", op)
-        }
-
-        // Cast to uintptr_t to avoid implicit pointer-to-int conversions.
-        Bitcast::PToI32 | Bitcast::PToL => format!("(uintptr_t) {}", op),
-
-        Bitcast::I32ToL | Bitcast::LToI32 | Bitcast::None => op.to_string(),
-
-        Bitcast::Sequence(sequence) => {
-            let [first, second] = &**sequence;
-            perform_cast(&perform_cast(op, first), second)
-        }
-    }
-}
-
 #[derive(Default, Clone, Copy)]
 enum SourceType {
     #[default]

crates/c/src/lib.rs

@@ -61,6 +61,7 @@ fn verify(dir: &Path, name: &str) {
         dir.to_str().unwrap(),
         "-Wall",
         "-Wextra",
+        "-Wc++-compat",
         "-Werror",
         "-Wno-unused-parameter",
         "-c",

crates/c/tests/codegen.rs

@@ -478,7 +478,7 @@ impl WorldGenerator for CSharp {
                 /* of WASI libc prevent us doing so. */
                 /* See https://github.com/bytecodealliance/wit-bindgen/issues/777  */
                 /* and https://github.com/WebAssembly/wasi-libc/issues/452 */
-                /* The component model `start` function might be an alternative to this depending on whether it
+                /* The component model `start` function might be an alternative to this depending on whether it */
                 /* has the same constraints as `cabi_realloc` */
                 __attribute__((__weak__, __export_name__("cabi_realloc")))
                 void *cabi_realloc(void *ptr, size_t old_size, size_t align, size_t new_size) {
@@ -586,7 +586,7 @@ impl WorldGenerator for CSharp {
             // temporarily add this attribute until it is available in dotnet 9
             namespace System.Runtime.InteropServices
             {
-                public class WasmImportLinkageAttribute : Attribute {}
+                internal partial class WasmImportLinkageAttribute : Attribute {}
             }
             "#,
         );

crates/csharp/src/lib.rs

@@ -13,10 +13,9 @@ Used when compiling Rust programs to the component model.
 
 [dependencies]
 wit-bindgen-rust-macro = { path = "./macro", optional = true, version = "0.22.0" }
-wit-bindgen-rt = { path = "./rt", optional = true, version = "0.22.0" }
-bitflags = { workspace = true }
+wit-bindgen-rt = { path = "./rt", version = "0.22.0", features = ["bitflags"] }
 
 [features]
 default = ["macros", "realloc"]
 macros = ["dep:wit-bindgen-rust-macro"]
-realloc = ["dep:wit-bindgen-rt"]
+realloc = []

crates/guest-rust/Cargo.toml

@@ -101,8 +101,8 @@ impl Parse for Config {
                     Opt::TypeSectionSuffix(suffix) => {
                         opts.type_section_suffix = Some(suffix.value());
                     }
-                    Opt::RunCtorsOnceWorkaround(enable) => {
-                        opts.run_ctors_once_workaround = enable.value();
+                    Opt::DisableRunCtorsOnceWorkaround(enable) => {
+                        opts.disable_run_ctors_once_workaround = enable.value();
                     }
                     Opt::DefaultBindingsModule(enable) => {
                         opts.default_bindings_module = Some(enable.value());
@@ -227,7 +227,7 @@ mod kw {
     syn::custom_keyword!(additional_derives);
     syn::custom_keyword!(with);
     syn::custom_keyword!(type_section_suffix);
-    syn::custom_keyword!(run_ctors_once_workaround);
+    syn::custom_keyword!(disable_run_ctors_once_workaround);
     syn::custom_keyword!(default_bindings_module);
     syn::custom_keyword!(export_macro_name);
     syn::custom_keyword!(pub_export_macro);
@@ -276,7 +276,7 @@ enum Opt {
     AdditionalDerives(Vec<syn::Path>),
     With(HashMap<String, String>),
     TypeSectionSuffix(syn::LitStr),
-    RunCtorsOnceWorkaround(syn::LitBool),
+    DisableRunCtorsOnceWorkaround(syn::LitBool),
     DefaultBindingsModule(syn::LitStr),
     ExportMacroName(syn::LitStr),
     PubExportMacro(syn::LitBool),
@@ -382,10 +382,10 @@ impl Parse for Opt {
             input.parse::<kw::type_section_suffix>()?;
             input.parse::<Token![:]>()?;
             Ok(Opt::TypeSectionSuffix(input.parse()?))
-        } else if l.peek(kw::run_ctors_once_workaround) {
-            input.parse::<kw::run_ctors_once_workaround>()?;
+        } else if l.peek(kw::disable_run_ctors_once_workaround) {
+            input.parse::<kw::disable_run_ctors_once_workaround>()?;
             input.parse::<Token![:]>()?;
-            Ok(Opt::RunCtorsOnceWorkaround(input.parse()?))
+            Ok(Opt::DisableRunCtorsOnceWorkaround(input.parse()?))
         } else if l.peek(kw::default_bindings_module) {
             input.parse::<kw::default_bindings_module>()?;
             input.parse::<Token![:]>()?;

crates/guest-rust/macro/src/lib.rs

@@ -8,3 +8,7 @@ homepage = 'https://github.com/bytecodealliance/wit-bindgen'
 description = """
 Runtime support for the `wit-bindgen` crate
 """
+
+[dependencies]
+# Optionally re-export the version of bitflags used by wit-bindgen.
+bitflags = { workspace = true, optional = true }

crates/guest-rust/rt/Cargo.toml

@@ -2,7 +2,13 @@
 
 extern crate alloc;
 
+// Re-export `bitflags` so that we can reference it from macros.
+#[cfg(feature = "bitflags")]
+#[doc(hidden)]
+pub use bitflags;
+
 /// For more information about this see `./ci/rebuild-libcabi-realloc.sh`.
+#[cfg(not(target_env = "p2"))]
 mod cabi_realloc;
 
 /// This function is called from generated bindings and will be deleted by
@@ -13,7 +19,7 @@ mod cabi_realloc;
 ///
 /// For more information about this see `./ci/rebuild-libcabi-realloc.sh`.
 pub fn maybe_link_cabi_realloc() {
-    #[cfg(target_family = "wasm")]
+    #[cfg(all(target_family = "wasm", not(target_env = "p2")))]
     {
         extern "C" {
             fn cabi_realloc(
@@ -44,6 +50,7 @@ pub fn maybe_link_cabi_realloc() {
 /// `cabi_realloc` module above. It's otherwise never explicitly called.
 ///
 /// For more information about this see `./ci/rebuild-libcabi-realloc.sh`.
+#[cfg(not(target_env = "p2"))]
 pub unsafe fn cabi_realloc(
     old_ptr: *mut u8,
     old_len: usize,
@@ -79,3 +86,29 @@ pub unsafe fn cabi_realloc(
     }
     return ptr;
 }
+
+/// Provide a hook for generated export functions to run static constructors at
+/// most once.
+///
+/// wit-bindgen-rust generates a call to this function at the start of all
+/// component export functions. Importantly, it is not called as part of
+/// `cabi_realloc`, which is a *core* export func, but should not execute ctors.
+#[cfg(target_arch = "wasm32")]
+pub fn run_ctors_once() {
+    static mut RUN: bool = false;
+    unsafe {
+        if !RUN {
+            // This function is synthesized by `wasm-ld` to run all static
+            // constructors. wasm-ld will either provide an implementation
+            // of this symbol, or synthesize a wrapper around each
+            // exported function to (unconditionally) run ctors. By using
+            // this function, the linked module is opting into "manually"
+            // running ctors.
+            extern "C" {
+                fn __wasm_call_ctors();
+            }
+            __wasm_call_ctors();
+            RUN = true;
+        }
+    }
+}