wasmtime 24.0.0 → 25.0.1

data/ext/cargo-vendor/wiggle-generate-25.0.1/src/names.rs

@@ -0,0 +1,299 @@
+use escaping::{escape_id, handle_2big_enum_variant, NamingConvention};
+use heck::{ToShoutySnakeCase, ToSnakeCase};
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote};
+use witx::{BuiltinType, Id, Type, TypeRef, WasmType};
+
+use crate::UserErrorType;
+
+pub fn type_(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::CamelCase)
+}
+
+pub fn builtin_type(b: BuiltinType) -> TokenStream {
+    match b {
+        BuiltinType::U8 { .. } => quote!(u8),
+        BuiltinType::U16 => quote!(u16),
+        BuiltinType::U32 { .. } => quote!(u32),
+        BuiltinType::U64 => quote!(u64),
+        BuiltinType::S8 => quote!(i8),
+        BuiltinType::S16 => quote!(i16),
+        BuiltinType::S32 => quote!(i32),
+        BuiltinType::S64 => quote!(i64),
+        BuiltinType::F32 => quote!(f32),
+        BuiltinType::F64 => quote!(f64),
+        BuiltinType::Char => quote!(char),
+    }
+}
+
+pub fn wasm_type(ty: WasmType) -> TokenStream {
+    match ty {
+        WasmType::I32 => quote!(i32),
+        WasmType::I64 => quote!(i64),
+        WasmType::F32 => quote!(f32),
+        WasmType::F64 => quote!(f64),
+    }
+}
+
+pub fn type_ref(tref: &TypeRef, lifetime: TokenStream) -> TokenStream {
+    match tref {
+        TypeRef::Name(nt) => {
+            let ident = type_(&nt.name);
+            quote!(#ident)
+        }
+        TypeRef::Value(ty) => match &**ty {
+            Type::Builtin(builtin) => builtin_type(*builtin),
+            Type::Pointer(pointee) | Type::ConstPointer(pointee) => {
+                let pointee_type = type_ref(&pointee, lifetime.clone());
+                quote!(wiggle::GuestPtr<#pointee_type>)
+            }
+            Type::List(pointee) => match &**pointee.type_() {
+                Type::Builtin(BuiltinType::Char) => {
+                    quote!(wiggle::GuestPtr<str>)
+                }
+                _ => {
+                    let pointee_type = type_ref(&pointee, lifetime.clone());
+                    quote!(wiggle::GuestPtr<[#pointee_type]>)
+                }
+            },
+            Type::Variant(v) => match v.as_expected() {
+                Some((ok, err)) => {
+                    let ok = match ok {
+                        Some(ty) => type_ref(ty, lifetime.clone()),
+                        None => quote!(()),
+                    };
+                    let err = match err {
+                        Some(ty) => type_ref(ty, lifetime.clone()),
+                        None => quote!(()),
+                    };
+                    quote!(Result<#ok, #err>)
+                }
+                None => unimplemented!("anonymous variant ref {:?}", tref),
+            },
+            Type::Record(r) if r.is_tuple() => {
+                let types = r
+                    .members
+                    .iter()
+                    .map(|m| type_ref(&m.tref, lifetime.clone()))
+                    .collect::<Vec<_>>();
+                quote!((#(#types,)*))
+            }
+            _ => unimplemented!("anonymous type ref {:?}", tref),
+        },
+    }
+}
+
+/// Convert an enum variant from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn enum_variant(id: &Id) -> Ident {
+    handle_2big_enum_variant(id).unwrap_or_else(|| escape_id(id, NamingConvention::CamelCase))
+}
+
+pub fn flag_member(id: &Id) -> Ident {
+    format_ident!("{}", id.as_str().to_shouty_snake_case())
+}
+
+pub fn int_member(id: &Id) -> Ident {
+    format_ident!("{}", id.as_str().to_shouty_snake_case())
+}
+
+/// Convert a struct member from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn struct_member(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a module name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn module(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a trait name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn trait_name(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::CamelCase)
+}
+
+/// Convert a function name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn func(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a parameter name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn func_param(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// For when you need a {name}_ptr binding for passing a value by reference:
+pub fn func_ptr_binding(id: &Id) -> Ident {
+    format_ident!("{}_ptr", id.as_str().to_snake_case())
+}
+
+/// For when you need a {name}_len binding for passing an array:
+pub fn func_len_binding(id: &Id) -> Ident {
+    format_ident!("{}_len", id.as_str().to_snake_case())
+}
+
+fn builtin_name(b: &BuiltinType) -> &'static str {
+    match b {
+        BuiltinType::U8 { .. } => "u8",
+        BuiltinType::U16 => "u16",
+        BuiltinType::U32 { .. } => "u32",
+        BuiltinType::U64 => "u64",
+        BuiltinType::S8 => "i8",
+        BuiltinType::S16 => "i16",
+        BuiltinType::S32 => "i32",
+        BuiltinType::S64 => "i64",
+        BuiltinType::F32 => "f32",
+        BuiltinType::F64 => "f64",
+        BuiltinType::Char => "char",
+    }
+}
+
+fn snake_typename(tref: &TypeRef) -> String {
+    match tref {
+        TypeRef::Name(nt) => nt.name.as_str().to_snake_case(),
+        TypeRef::Value(ty) => match &**ty {
+            Type::Builtin(b) => builtin_name(&b).to_owned(),
+            _ => panic!("unexpected anonymous type: {ty:?}"),
+        },
+    }
+}
+
+pub fn user_error_conversion_method(user_type: &UserErrorType) -> Ident {
+    let abi_type = snake_typename(&user_type.abi_type());
+    format_ident!(
+        "{}_from_{}",
+        abi_type,
+        user_type.method_fragment().to_snake_case()
+    )
+}
+
+/// Identifier escaping utilities.
+///
+/// This module most importantly exports an `escape_id` function that can be used to properly
+/// escape tokens that conflict with strict and reserved keywords, as of Rust's 2018 edition.
+///
+/// Weak keywords are not included as their semantic rules do not have the same implications as
+/// those of strict and reserved keywords. `union` for example, is permitted as the name of a
+/// variable. `dyn` was promoted to a strict keyword beginning in the 2018 edition.
+mod escaping {
+    use {
+        heck::{ToSnakeCase, ToUpperCamelCase},
+        proc_macro2::Ident,
+        quote::format_ident,
+        witx::Id,
+    };
+
+    /// Identifier naming convention.
+    ///
+    /// Because shouty snake case values (identifiers that look `LIKE_THIS`) cannot potentially
+    /// conflict with any Rust keywords, this enum only include snake and camel case variants.
+    pub enum NamingConvention {
+        /// Snake case. Used to denote values `LikeThis`.
+        CamelCase,
+        /// Snake case. Used to denote values `like_this`.
+        SnakeCase,
+    }
+
+    /// Given a witx [`Id`][witx] and a [`NamingConvention`][naming], return a [`Ident`] word of
+    /// Rust syntax that accounts for escaping both strict and reserved keywords. If an identifier
+    /// would have conflicted with a keyword, a trailing underscode will be appended.
+    ///
+    /// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+    /// [naming]: enum.NamingConvention.html
+    /// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+    pub fn escape_id(id: &Id, conv: NamingConvention) -> Ident {
+        use NamingConvention::{CamelCase, SnakeCase};
+        match (conv, id.as_str()) {
+            // For camel-cased identifiers, `Self` is the only potential keyword conflict.
+            (CamelCase, "self") => format_ident!("Self_"),
+            (CamelCase, s) => format_ident!("{}", s.to_upper_camel_case()),
+            // Snake-cased identifiers are where the bulk of conflicts can occur.
+            (SnakeCase, s) => {
+                let s = s.to_snake_case();
+                if STRICT.iter().chain(RESERVED).any(|k| *k == s) {
+                    // If the camel-cased string matched any strict or reserved keywords, then
+                    // append a trailing underscore to the identifier we generate.
+                    format_ident!("{}_", s)
+                } else {
+                    format_ident!("{}", s) // Otherwise, use the string as is.
+                }
+            }
+        }
+    }
+
+    /// Strict keywords.
+    ///
+    /// >  Strict keywords cannot be used as the names of:
+    /// >    * Items
+    /// >    * Variables and function parameters
+    /// >    * Fields and variants
+    /// >    * Type parameters
+    /// >    * Lifetime parameters or loop labels
+    /// >    * Macros or attributes
+    /// >    * Macro placeholders
+    /// >    * Crates
+    /// >
+    /// > - <cite>[The Rust Reference][ref]</cite>
+    ///
+    /// This list also includes keywords that were introduced in the 2018 edition of Rust.
+    ///
+    /// [ref]: https://doc.rust-lang.org/reference/keywords.html#strict-keywords
+    const STRICT: &[&str] = &[
+        "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
+        "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move",
+        "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait",
+        "true", "type", "unsafe", "use", "where", "while",
+    ];
+
+    /// Reserved keywords.
+    ///
+    /// > These keywords aren't used yet, but they are reserved for future use. They have the same
+    /// > restrictions as strict keywords. The reasoning behind this is to make current programs
+    /// > forward compatible with future versions of Rust by forbidding them to use these keywords.
+    /// >
+    /// > - <cite>[The Rust Reference][ref]</cite>
+    ///
+    /// This list also includes keywords that were introduced in the 2018 edition of Rust.
+    ///
+    /// [ref]: https://doc.rust-lang.org/reference/keywords.html#reserved-keywords
+    const RESERVED: &[&str] = &[
+        "abstract", "become", "box", "do", "final", "macro", "override", "priv", "try", "typeof",
+        "unsized", "virtual", "yield",
+    ];
+
+    /// Handle WASI's [`errno::2big`][err] variant.
+    ///
+    /// This is an unfortunate edge case that must account for when generating `enum` variants.
+    /// This will only return `Some(_)` if the given witx identifier *is* `2big`, otherwise this
+    /// function will return `None`.
+    ///
+    /// This functionality is a short-term fix that keeps WASI working. Instead of expanding these sort of special cases,
+    /// we should replace this function by having the user provide a mapping of witx identifiers to Rust identifiers in the
+    /// arguments to the macro.
+    ///
+    /// [err]: https://github.com/WebAssembly/WASI/blob/master/phases/snapshot/docs.md#-errno-enumu16
+    pub fn handle_2big_enum_variant(id: &Id) -> Option<Ident> {
+        if id.as_str() == "2big" {
+            Some(format_ident!("TooBig"))
+        } else {
+            None
+        }
+    }
+}

data/ext/cargo-vendor/wiggle-generate-25.0.1/src/wasmtime.rs

@@ -0,0 +1,172 @@
+use crate::config::Asyncness;
+use crate::funcs::func_bounds;
+use crate::names;
+use crate::CodegenSettings;
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::{format_ident, quote};
+use std::collections::HashSet;
+
+pub fn link_module(
+    module: &witx::Module,
+    target_path: Option<&syn::Path>,
+    settings: &CodegenSettings,
+) -> TokenStream {
+    let module_ident = names::module(&module.name);
+
+    let send_bound = if settings.async_.contains_async(module) {
+        quote! { + Send, T: Send }
+    } else {
+        quote! {}
+    };
+
+    let mut bodies = Vec::new();
+    let mut bounds = HashSet::new();
+    for f in module.funcs() {
+        let asyncness = settings.async_.get(module.name.as_str(), f.name.as_str());
+        bodies.push(generate_func(&module, &f, target_path, asyncness));
+        let bound = func_bounds(module, &f, settings);
+        for b in bound {
+            bounds.insert(b);
+        }
+    }
+
+    let ctx_bound = if let Some(target_path) = target_path {
+        let bounds = bounds
+            .into_iter()
+            .map(|b| quote!(#target_path::#module_ident::#b));
+        quote!( #(#bounds)+* #send_bound )
+    } else {
+        let bounds = bounds.into_iter();
+        quote!( #(#bounds)+* #send_bound )
+    };
+
+    let func_name = if target_path.is_none() {
+        format_ident!("add_to_linker")
+    } else {
+        format_ident!("add_{}_to_linker", module_ident)
+    };
+
+    let u = if settings.mutable {
+        quote!(&mut U)
+    } else {
+        quote!(&U)
+    };
+    quote! {
+        /// Adds all instance items to the specified `Linker`.
+        pub fn #func_name<T, U>(
+            linker: &mut wiggle::wasmtime_crate::Linker<T>,
+            get_cx: impl Fn(&mut T) -> #u + Send + Sync + Copy + 'static,
+        ) -> wiggle::anyhow::Result<()>
+            where
+                U: #ctx_bound #send_bound
+        {
+            #(#bodies)*
+            Ok(())
+        }
+    }
+}
+
+fn generate_func(
+    module: &witx::Module,
+    func: &witx::InterfaceFunc,
+    target_path: Option<&syn::Path>,
+    asyncness: Asyncness,
+) -> TokenStream {
+    let module_str = module.name.as_str();
+    let module_ident = names::module(&module.name);
+
+    let field_str = func.name.as_str();
+    let field_ident = names::func(&func.name);
+
+    let (params, results) = func.wasm_signature();
+
+    let arg_names = (0..params.len())
+        .map(|i| Ident::new(&format!("arg{i}"), Span::call_site()))
+        .collect::<Vec<_>>();
+    let arg_tys = params
+        .iter()
+        .map(|ty| names::wasm_type(*ty))
+        .collect::<Vec<_>>();
+    let arg_decls = arg_names
+        .iter()
+        .zip(arg_tys.iter())
+        .map(|(name, ty)| {
+            quote! { #name: #ty }
+        })
+        .collect::<Vec<_>>();
+
+    let ret_ty = match results.len() {
+        0 => quote!(()),
+        1 => names::wasm_type(results[0]),
+        _ => unimplemented!(),
+    };
+
+    let await_ = if asyncness.is_sync() {
+        quote!()
+    } else {
+        quote!(.await)
+    };
+
+    let abi_func = if let Some(target_path) = target_path {
+        quote!( #target_path::#module_ident::#field_ident )
+    } else {
+        quote!( #field_ident )
+    };
+
+    let body = quote! {
+        let export = caller.get_export("memory");
+        let (mut mem, ctx) = match &export {
+            Some(wiggle::wasmtime_crate::Extern::Memory(m)) => {
+                let (mem, ctx) = m.data_and_store_mut(&mut caller);
+                let ctx = get_cx(ctx);
+                (wiggle::GuestMemory::Unshared(mem), ctx)
+            }
+            Some(wiggle::wasmtime_crate::Extern::SharedMemory(m)) => {
+                let ctx = get_cx(caller.data_mut());
+                (wiggle::GuestMemory::Shared(m.data()), ctx)
+            }
+            _ => wiggle::anyhow::bail!("missing required memory export"),
+        };
+        Ok(<#ret_ty>::from(#abi_func(ctx, &mut mem #(, #arg_names)*) #await_ ?))
+    };
+
+    match asyncness {
+        Asyncness::Async => {
+            let arg_decls = quote! { ( #(#arg_names,)* ) : ( #(#arg_tys,)* ) };
+            quote! {
+                linker.func_wrap_async(
+                    #module_str,
+                    #field_str,
+                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T>, #arg_decls| {
+                        Box::new(async move { #body })
+                    },
+                )?;
+            }
+        }
+
+        Asyncness::Blocking { block_with } => {
+            quote! {
+                linker.func_wrap(
+                    #module_str,
+                    #field_str,
+                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| -> wiggle::anyhow::Result<#ret_ty> {
+                        let result = async { #body };
+                        #block_with(result)?
+                    },
+                )?;
+            }
+        }
+
+        Asyncness::Sync => {
+            quote! {
+                linker.func_wrap(
+                    #module_str,
+                    #field_str,
+                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| -> wiggle::anyhow::Result<#ret_ty> {
+                        #body
+                    },
+                )?;
+            }
+        }
+    }
+}

data/ext/cargo-vendor/wiggle-macro-25.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"8a7cc8121d98799f12d267944cc4982ae8b659ea0c150ec963ad80e9763701f2","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"0067e626dfcf105d55adda251ed37b72dd4797c764dc8bf08511d847fc7a4a7a","src/lib.rs":"b21cc01942c1c6f285221fc886c42817f9e64b9fe3c004f5c56e90eab38b93bc"},"package":"2706ee9e7d1e106de80a3b3c6ec2f42920149e2def3e8060187c8e61f99bc0ef"}

data/ext/cargo-vendor/wiggle-macro-25.0.1/Cargo.toml

@@ -0,0 +1,78 @@
+# 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"
+rust-version = "1.78.0"
+name = "wiggle-macro"
+version = "25.0.1"
+authors = [
+    "Pat Hickey <phickey@fastly.com>",
+    "Jakub Konka <kubkon@jakubkonka.com>",
+    "Alex Crichton <alex@alexcrichton.com>",
+]
+build = "build.rs"
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Wiggle code generator"
+readme = false
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+name = "wiggle_macro"
+path = "src/lib.rs"
+test = false
+doctest = false
+proc-macro = true
+
+[dependencies.proc-macro2]
+version = "1.0"
+
+[dependencies.quote]
+version = "1.0"
+
+[dependencies.syn]
+version = "2.0.25"
+features = ["full"]
+
+[dependencies.wiggle-generate]
+version = "=25.0.1"
+
+[dev-dependencies]
+
+[features]
+wiggle_metadata = []
+
+[lints.clippy]
+clone_on_copy = "warn"
+manual_strip = "warn"
+map_clone = "warn"
+uninlined_format_args = "warn"
+unnecessary_to_owned = "warn"
+
+[lints.clippy.all]
+level = "allow"
+priority = -1
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/winch-codegen-0.23.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"47539ddbc4e7bc08ef13c467bf5bb713b4bd1ef8c85e294301d4b7ca8e58f5c4","LICENSE":"a6c48161a09acc75a0e25503bab66a731eb5fba5392ed4bb4743e4ba5085327a","build.rs":"d19fe439db9b48a8bf91af26001c20ea6010633133bc52a13679720187a7cf1b","src/abi/local.rs":"459824112186b47bcbb7efb8ff18e8eaa3729c22dd15cb6ee624c24ea33afe3f","src/abi/mod.rs":"4430c64d46d9c6929c16bd2c3cca57a9152186dea49afdd0d0f870f03c5949c8","src/codegen/bounds.rs":"32e7ab2721b4c3c1b7c4da6568a819f265d8772a8663334f72649fd42735a879","src/codegen/builtin.rs":"534d652d00676e2be629145a94f7b08feebb0595e65b58351cdb26afacfba3f3","src/codegen/call.rs":"43ed99a08969d4c566ed4724b1d57457e1d4e3d60230abc6cb67949069921ccc","src/codegen/context.rs":"aac7d6ba8011dd66cd36c790de6814f0abf53e7d5bc5a9104ab1c3e6004b4da2","src/codegen/control.rs":"7432b91f1d86ba02b3a02427c4e5eaea923b3ed2bcfd5d280cdd5f9edd682e35","src/codegen/env.rs":"dc83f063fd2ec89b6e7290b02cf50a27b4ddfabe3cdfdccede837d94ef6f6c5b","src/codegen/mod.rs":"e23128d282782ddb27e6becb5eaafd4765a67517a15a515cefe7028fca222795","src/frame/mod.rs":"c06c6104ea7e887391739e6f7c8fc747b3ecd495a71cc047f6ceb18abe28fa2f","src/isa/aarch64/abi.rs":"a277b2ca8fcf1290a572f533f705d58843943db4932aa193fe1ed86dfab7665a","src/isa/aarch64/address.rs":"37409e03f345d14ced961033073ea0221e8057c0d104e0fac97f9d55f1a65a6e","src/isa/aarch64/asm.rs":"928b0c35d54f008c73bb354692754f3fe5219c94fdc0cd3b29e5d05620dbe524","src/isa/aarch64/masm.rs":"74841766c8b7dd099fce8417bbd06471ebc8faad7183f89471c5c8c582957b36","src/isa/aarch64/mod.rs":"938c5a859f54c184eeff3ffc3a225decff811a5be3f31b505a73a1b68c8d1c3c","src/isa/aarch64/regs.rs":"2a4bb7afa2d2c42f391a524ab82960af67eb5a965da1d579e80b9fc6da446c5d","src/isa/mod.rs":"07e049e4b4ef67c602706ad7a022eb88c614e0252cc540d6e33a9d3379786ae6","src/isa/reg.rs":"09e4abe918307f996bcb6df34531759253007480582ea89e3c7ae569907b632b","src/isa/x64/abi.rs":"55ab5bf2cc529dc4bc4fdef47517cff0ac41902da4169a70e4a2d0b83583c9d8","src/isa/x64/address.rs":"50245c51730ab31064628882d24155ba676803c29875ac9d226d081af9f6700d","src/isa/x64/asm.rs":"bf515384f38bbaa9110cea70300edb3391bcb2d5284c9f64d7ecb68548fd568c","src/isa/x64/masm.rs":"2121aabe04fce75ab7971606e9af81dff69cfdb753aa27aee83c773a2c8f12b6","src/isa/x64/mod.rs":"58ee9a43fd750cbda62ece716d4e88796f813bd089c9766be82ec4ca71f6dbea","src/isa/x64/regs.rs":"b8650a8d61e448393a1eb9e47120b05033fc429f6e7762ff2ad04e23b0877850","src/lib.rs":"ff6ec9d65c59b5f4d2d8561da13866c9c0bd5e5cccb106c61a35bd030f1339ce","src/masm.rs":"62eb2f18402ede99dcbb7f43de3c65040bdccde05943935e379e28ec02d579ad","src/regalloc.rs":"4c1d55b454d04a131816611afdc7e29477d6829b259c8089eaf524683b1aeb86","src/regset.rs":"0c7d9eb05178333faeeaa1a784c5ff326ec60f858a78c149e592724119d0be25","src/stack.rs":"9e98bca14ee5fa317d3db86597bd2b8fa36a0fbd85e468f18322c6adc2431885","src/visitor.rs":"5491ac7be02a2f469fcd724a8558dfe53aae75fce039e8decc30bf461b7e5afa"},"package":"4ac790aaeff15764481c731239a45346df3f0af966839ac1575f49989fdbb542"}

data/ext/cargo-vendor/winch-codegen-0.23.1/Cargo.toml

@@ -0,0 +1,95 @@
+# 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"
+rust-version = "1.78.0"
+name = "winch-codegen"
+version = "0.23.1"
+authors = ["The Winch Project Developers"]
+build = "build.rs"
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Winch code generation library"
+readme = false
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+name = "winch_codegen"
+path = "src/lib.rs"
+
+[dependencies.anyhow]
+version = "1.0.22"
+default-features = false
+
+[dependencies.cranelift-codegen]
+version = "0.112.1"
+features = [
+    "std",
+    "unwind",
+    "unwind",
+]
+default-features = false
+
+[dependencies.gimli]
+version = "0.29.0"
+features = ["read"]
+default-features = false
+
+[dependencies.regalloc2]
+version = "0.10.2"
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.16"
+features = ["std"]
+
+[dependencies.wasmparser]
+version = "0.217.0"
+default-features = false
+
+[dependencies.wasmtime-cranelift]
+version = "=25.0.1"
+
+[dependencies.wasmtime-environ]
+version = "=25.0.1"
+
+[features]
+all-arch = [
+    "x64",
+    "arm64",
+]
+arm64 = ["cranelift-codegen/arm64"]
+x64 = ["cranelift-codegen/x86"]
+
+[lints.clippy]
+clone_on_copy = "warn"
+manual_strip = "warn"
+map_clone = "warn"
+uninlined_format_args = "warn"
+unnecessary_to_owned = "warn"
+
+[lints.clippy.all]
+level = "allow"
+priority = -1
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"