wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmtime-winch-16.0.0/src/compiler.rs

@@ -0,0 +1,243 @@
+use anyhow::Result;
+use object::write::{Object, SymbolId};
+use std::any::Any;
+use std::mem;
+use std::sync::Mutex;
+use wasmparser::FuncValidatorAllocations;
+use wasmtime_cranelift_shared::{CompiledFunction, ModuleTextBuilder};
+use wasmtime_environ::{
+    CompileError, DefinedFuncIndex, FilePos, FuncIndex, FunctionBodyData, FunctionLoc,
+    ModuleTranslation, ModuleTypesBuilder, PrimaryMap, TrapEncodingBuilder, VMOffsets,
+    WasmFunctionInfo,
+};
+use winch_codegen::{BuiltinFunctions, TargetIsa, TrampolineKind};
+
+/// Function compilation context.
+/// This struct holds information that can be shared globally across
+/// all function compilations.
+struct CompilationContext {
+    /// Validator allocations.
+    allocations: FuncValidatorAllocations,
+    /// Builtin functions available to JIT code.
+    builtins: BuiltinFunctions,
+}
+
+pub(crate) struct Compiler {
+    isa: Box<dyn TargetIsa>,
+    contexts: Mutex<Vec<CompilationContext>>,
+}
+
+/// The compiled function environment.
+pub struct CompiledFuncEnv;
+impl wasmtime_cranelift_shared::CompiledFuncEnv for CompiledFuncEnv {
+    fn resolve_user_external_name_ref(
+        &self,
+        external: cranelift_codegen::ir::UserExternalNameRef,
+    ) -> (u32, u32) {
+        (0, external.as_u32())
+    }
+}
+
+impl Compiler {
+    pub fn new(isa: Box<dyn TargetIsa>) -> Self {
+        Self {
+            isa,
+            contexts: Mutex::new(Vec::new()),
+        }
+    }
+
+    /// Get a compilation context or create a new one if none available.
+    fn get_context(&self, translation: &ModuleTranslation) -> CompilationContext {
+        self.contexts.lock().unwrap().pop().unwrap_or_else(|| {
+            let pointer_size = self.isa.pointer_bytes();
+            let vmoffsets = VMOffsets::new(pointer_size, &translation.module);
+            CompilationContext {
+                allocations: Default::default(),
+                builtins: BuiltinFunctions::new(&vmoffsets, self.isa.wasmtime_call_conv()),
+            }
+        })
+    }
+
+    /// Save a compilation context.
+    fn save_context(&self, mut context: CompilationContext, allocs: FuncValidatorAllocations) {
+        context.allocations = allocs;
+        self.contexts.lock().unwrap().push(context);
+    }
+}
+
+impl wasmtime_environ::Compiler for Compiler {
+    fn compile_function(
+        &self,
+        translation: &ModuleTranslation<'_>,
+        index: DefinedFuncIndex,
+        data: FunctionBodyData<'_>,
+        types: &ModuleTypesBuilder,
+    ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError> {
+        let index = translation.module.func_index(index);
+        let sig = translation.module.functions[index].signature;
+        let ty = &types[sig];
+        let FunctionBodyData { body, validator } = data;
+        let start_srcloc = FilePos::new(
+            body.get_binary_reader()
+                .original_position()
+                .try_into()
+                .unwrap(),
+        );
+        let mut context = self.get_context(translation);
+        let mut validator = validator.into_validator(mem::take(&mut context.allocations));
+        let buffer = self
+            .isa
+            .compile_function(
+                ty,
+                &body,
+                translation,
+                types,
+                &mut context.builtins,
+                &mut validator,
+            )
+            .map_err(|e| CompileError::Codegen(format!("{e:?}")));
+        self.save_context(context, validator.into_allocations());
+        let buffer = buffer?;
+        let compiled_function =
+            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
+
+        Ok((
+            WasmFunctionInfo {
+                start_srcloc,
+                stack_maps: Box::new([]),
+            },
+            Box::new(compiled_function),
+        ))
+    }
+
+    fn compile_array_to_wasm_trampoline(
+        &self,
+        translation: &ModuleTranslation<'_>,
+        types: &ModuleTypesBuilder,
+        index: DefinedFuncIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError> {
+        let func_index = translation.module.func_index(index);
+        let sig = translation.module.functions[func_index].signature;
+        let ty = &types[sig];
+        let buffer = self
+            .isa
+            .compile_trampoline(&ty, TrampolineKind::ArrayToWasm(func_index))
+            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
+        let compiled_function =
+            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
+
+        Ok(Box::new(compiled_function))
+    }
+
+    fn compile_native_to_wasm_trampoline(
+        &self,
+        translation: &ModuleTranslation<'_>,
+        types: &ModuleTypesBuilder,
+        index: DefinedFuncIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError> {
+        let func_index = translation.module.func_index(index);
+        let sig = translation.module.functions[func_index].signature;
+        let ty = &types[sig];
+
+        let buffer = self
+            .isa
+            .compile_trampoline(ty, TrampolineKind::NativeToWasm(func_index))
+            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
+
+        let compiled_function =
+            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
+
+        Ok(Box::new(compiled_function))
+    }
+
+    fn compile_wasm_to_native_trampoline(
+        &self,
+        wasm_func_ty: &wasmtime_environ::WasmFuncType,
+    ) -> Result<Box<dyn Any + Send>, CompileError> {
+        let buffer = self
+            .isa
+            .compile_trampoline(wasm_func_ty, TrampolineKind::WasmToNative)
+            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
+
+        let compiled_function =
+            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
+
+        Ok(Box::new(compiled_function))
+    }
+
+    fn append_code(
+        &self,
+        obj: &mut Object<'static>,
+        funcs: &[(String, Box<dyn Any + Send>)],
+        resolve_reloc: &dyn Fn(usize, FuncIndex) -> usize,
+    ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
+        let mut builder =
+            ModuleTextBuilder::new(obj, self, self.isa.text_section_builder(funcs.len()));
+        let mut traps = TrapEncodingBuilder::default();
+
+        let mut ret = Vec::with_capacity(funcs.len());
+        for (i, (sym, func)) in funcs.iter().enumerate() {
+            let func = func
+                .downcast_ref::<CompiledFunction<CompiledFuncEnv>>()
+                .unwrap();
+
+            let (sym, range) = builder.append_func(&sym, func, |idx| resolve_reloc(i, idx));
+            traps.push(range.clone(), &func.traps().collect::<Vec<_>>());
+
+            let info = FunctionLoc {
+                start: u32::try_from(range.start).unwrap(),
+                length: u32::try_from(range.end - range.start).unwrap(),
+            };
+            ret.push((sym, info));
+        }
+        builder.finish();
+        traps.append_to(obj);
+        Ok(ret)
+    }
+
+    fn emit_trampolines_for_array_call_host_func(
+        &self,
+        ty: &wasmtime_environ::WasmFuncType,
+        // Actually `host_fn: VMArrayCallFunction` but that type is not
+        // available in `wasmtime-environ`.
+        host_fn: usize,
+        obj: &mut Object<'static>,
+    ) -> Result<(FunctionLoc, FunctionLoc)> {
+        drop((ty, host_fn, obj));
+        todo!()
+    }
+
+    fn triple(&self) -> &target_lexicon::Triple {
+        self.isa.triple()
+    }
+
+    fn flags(&self) -> Vec<(&'static str, wasmtime_environ::FlagValue<'static>)> {
+        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.flags().iter())
+    }
+
+    fn isa_flags(&self) -> Vec<(&'static str, wasmtime_environ::FlagValue<'static>)> {
+        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.isa_flags())
+    }
+
+    fn is_branch_protection_enabled(&self) -> bool {
+        self.isa.is_branch_protection_enabled()
+    }
+
+    #[cfg(feature = "component-model")]
+    fn component_compiler(&self) -> &dyn wasmtime_environ::component::ComponentCompiler {
+        todo!()
+    }
+
+    fn append_dwarf(
+        &self,
+        _obj: &mut Object<'_>,
+        _translation: &ModuleTranslation<'_>,
+        _funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
+    ) -> Result<()> {
+        todo!()
+    }
+
+    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
+        self.isa.create_systemv_cie()
+    }
+}

data/ext/cargo-vendor/wasmtime-wit-bindgen-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"46e97f781eb1840468b3f86278114c792f27ed39143bce6a3350485395be397f","src/lib.rs":"e73c583f082bd5f4df08417c8a36b70f279d25d76e4323e08a6d381d75ee0228","src/rust.rs":"0d75c2ff8e45df807371a1b48ebb22bf415aceac43e4a6e24b2edbe641cfaeae","src/source.rs":"91baa5428613f797af37784d73fe04cbad1afaf2f95bed66606adfde6fe5e214","src/types.rs":"7b250f5e4a744b4a4df93c3988fb47cfa7d9b3921d206ffede16275f6c5dcb26"},"package":"f328b2d4a690270324756e886ed5be3a4da4c00be0eea48253f4595ad068062b"}

data/ext/cargo-vendor/wasmtime-wit-bindgen-16.0.0/Cargo.toml

@@ -0,0 +1,41 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wasmtime-wit-bindgen"
+version = "16.0.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Internal `*.wit` support for the `wasmtime` crate's macros"
+documentation = "https://docs.rs/wasmtime-wit-bindgen/"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.heck]
+version = "0.4"
+
+[dependencies.indexmap]
+version = "2.0.0"
+
+[dependencies.wit-parser]
+version = "0.13.0"
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasmtime-wmemcheck-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"8e6a5cc14c7823522c7598eeac67ed3622eeabe1dcdd9bd923d5017f4e0dd314","src/lib.rs":"dc10cf0aa79863356d6ca481f09a735ac07f3bef079f997e736892acd2f3ede1"},"package":"67761d8f8c0b3c13a5d34356274b10a40baba67fe9cfabbfc379a8b414e45de2"}

data/ext/cargo-vendor/wasmtime-wmemcheck-16.0.0/Cargo.toml

@@ -0,0 +1,29 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wasmtime-wmemcheck"
+version = "16.0.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Memcheck implementation for Wasmtime"
+documentation = "https://docs.rs/wasmtime-cranelift/"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wiggle-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"89116c6883619083de68b61f289c606091de959305daa7d36474a39cb56b8090","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"21422dca0d2d4fd0e55a8cb795e26fc5ba1d6ca84c309c8d7f2344b1b47bdf17","src/borrow.rs":"e333dd895b9f286c5e672539548b1bf245b9efd69b78f5451b1cde5766553fe2","src/error.rs":"deb6a444431fe40eef837b5db8f4f5fa82ef8a03bb9957c3688895d5f6d7bd20","src/guest_type.rs":"75dc917d187e4854d50bdf2550a52ee9e1f17cdd657cbd486db1891e47b93676","src/lib.rs":"e813a49ffc4ccf2cec8bcf8e81f1e45dfac249b4001a90e54519099599071969","src/region.rs":"5a4e9284148747f00dbe08831b87c5c2528e68eff266a6f1996fcb11d00ed821","src/wasmtime.rs":"2e9b87395919048ff034c6a4925003f428f5454d274b3205a96803e1010c6cb1"},"package":"0afb26cd3269289bb314a361ff0a6685e5ce793b62181a9fe3f81ace15051697"}

data/ext/cargo-vendor/wiggle-16.0.0/Cargo.toml

@@ -0,0 +1,115 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wiggle"
+version = "16.0.0"
+authors = [
+    "Pat Hickey <phickey@fastly.com>",
+    "Jakub Konka <kubkonk@jakubkonka.com>",
+    "Alex Crichton <alex@alexcrichton.com>",
+]
+include = [
+    "src/**/*",
+    "README.md",
+    "LICENSE",
+]
+description = "Runtime components of wiggle code generator"
+readme = "README.md"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[[test]]
+name = "atoms_async"
+path = "tests/atoms_async.rs"
+required-features = ["wasmtime_async"]
+
+[[test]]
+name = "wasmtime_async"
+path = "tests/wasmtime_async.rs"
+required-features = [
+    "wasmtime_async",
+    "wasmtime/wat",
+]
+
+[[test]]
+name = "wasmtime_sync"
+path = "tests/wasmtime_sync.rs"
+required-features = ["wasmtime/wat"]
+
+[[test]]
+name = "wasmtime_integration"
+path = "tests/wasmtime_integration.rs"
+required-features = ["wasmtime/wat"]
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.async-trait]
+version = "0.1.71"
+
+[dependencies.bitflags]
+version = "2.0"
+
+[dependencies.thiserror]
+version = "1.0.43"
+
+[dependencies.tracing]
+version = "0.1.26"
+
+[dependencies.wasmtime]
+version = "16.0.0"
+default-features = false
+
+[dependencies.wiggle-macro]
+version = "=16.0.0"
+
+[dependencies.witx]
+version = "0.9.1"
+optional = true
+
+[dev-dependencies.proptest]
+version = "1.0.0"
+
+[dev-dependencies.tokio]
+version = "1"
+features = [
+    "rt-multi-thread",
+    "time",
+    "macros",
+]
+
+[features]
+default = [
+    "wiggle_metadata",
+    "wasmtime_async",
+]
+tracing_log = ["tracing/log"]
+wasmtime_async = ["wasmtime/async"]
+wiggle_metadata = [
+    "witx",
+    "wiggle-macro/wiggle_metadata",
+]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"