wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/winapi-util-0.1.9/src/sysinfo.rs

@@ -0,0 +1,161 @@
+use std::{ffi::OsString, io};
+
+use windows_sys::Win32::System::SystemInformation::{
+    GetComputerNameExW, COMPUTER_NAME_FORMAT,
+};
+
+/// The type of name to be retrieved by [`get_computer_name`].
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub enum ComputerNameKind {
+    /// The name of the DNS domain assigned to the local computer. If the local
+    /// computer is a node in a cluster, lpBuffer receives the DNS domain name
+    /// of the cluster virtual server.
+    DnsDomain,
+    /// The fully qualified DNS name that uniquely identifies the local
+    /// computer. This name is a combination of the DNS host name and the DNS
+    /// domain name, using the form HostName.DomainName. If the local computer
+    /// is a node in a cluster, lpBuffer receives the fully qualified DNS name
+    /// of the cluster virtual server.
+    DnsFullyQualified,
+    /// The DNS host name of the local computer. If the local computer is a
+    /// node in a cluster, lpBuffer receives the DNS host name of the cluster
+    /// virtual server.
+    DnsHostname,
+    /// The NetBIOS name of the local computer. If the local computer is a node
+    /// in a cluster, lpBuffer receives the NetBIOS name of the cluster virtual
+    /// server.
+    NetBios,
+    /// The name of the DNS domain assigned to the local computer. If the local
+    /// computer is a node in a cluster, lpBuffer receives the DNS domain name
+    /// of the local computer, not the name of the cluster virtual server.
+    PhysicalDnsDomain,
+    /// The fully qualified DNS name that uniquely identifies the computer. If
+    /// the local computer is a node in a cluster, lpBuffer receives the fully
+    /// qualified DNS name of the local computer, not the name of the cluster
+    /// virtual server.
+    ///
+    /// The fully qualified DNS name is a combination of the DNS host name and
+    /// the DNS domain name, using the form HostName.DomainName.
+    PhysicalDnsFullyQualified,
+    /// The DNS host name of the local computer. If the local computer is a
+    /// node in a cluster, lpBuffer receives the DNS host name of the local
+    /// computer, not the name of the cluster virtual server.
+    PhysicalDnsHostname,
+    /// The NetBIOS name of the local computer. If the local computer is a node
+    /// in a cluster, lpBuffer receives the NetBIOS name of the local computer,
+    /// not the name of the cluster virtual server.
+    PhysicalNetBios,
+}
+
+impl ComputerNameKind {
+    fn to_format(&self) -> COMPUTER_NAME_FORMAT {
+        use self::ComputerNameKind::*;
+        use windows_sys::Win32::System::SystemInformation;
+
+        match *self {
+            DnsDomain => SystemInformation::ComputerNameDnsDomain,
+            DnsFullyQualified => {
+                SystemInformation::ComputerNameDnsFullyQualified
+            }
+            DnsHostname => SystemInformation::ComputerNameDnsHostname,
+            NetBios => SystemInformation::ComputerNameNetBIOS,
+            PhysicalDnsDomain => {
+                SystemInformation::ComputerNamePhysicalDnsDomain
+            }
+            PhysicalDnsFullyQualified => {
+                SystemInformation::ComputerNamePhysicalDnsFullyQualified
+            }
+            PhysicalDnsHostname => {
+                SystemInformation::ComputerNamePhysicalDnsHostname
+            }
+            PhysicalNetBios => SystemInformation::ComputerNamePhysicalNetBIOS,
+        }
+    }
+}
+/// Retrieves a NetBIOS or DNS name associated with the local computer.
+///
+/// The names are established at system startup, when the system reads them
+/// from the registry.
+///
+/// This corresponds to calling [`GetComputerNameExW`].
+///
+/// [`GetComputerNameExW`]: https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getcomputernameexw
+pub fn get_computer_name(kind: ComputerNameKind) -> io::Result<OsString> {
+    use std::os::windows::ffi::OsStringExt;
+
+    let format = kind.to_format();
+    let mut len1 = 0;
+    // SAFETY: As documented, we call this with a null pointer which will in
+    // turn cause this routine to write the required buffer size fo `len1`.
+    // Also, we explicitly ignore the return value since we expect this call to
+    // fail given that the destination buffer is too small by design.
+    let _ =
+        unsafe { GetComputerNameExW(format, std::ptr::null_mut(), &mut len1) };
+
+    let len = match usize::try_from(len1) {
+        Ok(len) => len,
+        Err(_) => {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "GetComputerNameExW buffer length overflowed usize",
+            ))
+        }
+    };
+    let mut buf = vec![0; len];
+    let mut len2 = len1;
+    // SAFETY: We pass a valid pointer to an appropriately sized Vec<u16>.
+    let rc =
+        unsafe { GetComputerNameExW(format, buf.as_mut_ptr(), &mut len2) };
+    if rc == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    // Apparently, the subsequent call writes the number of characters written
+    // to the buffer to `len2` but not including the NUL terminator. Notice
+    // that in the first call above, the length written to `len1` *does*
+    // include the NUL terminator. Therefore, we expect `len1` to be at least
+    // one greater than `len2`. If not, then something weird has happened and
+    // we report an error.
+    if len1 <= len2 {
+        let msg = format!(
+            "GetComputerNameExW buffer length mismatch, \
+             expected length strictly less than {} \
+             but got {}",
+            len1, len2,
+        );
+        return Err(io::Error::new(io::ErrorKind::Other, msg));
+    }
+    let len = usize::try_from(len2).expect("len1 fits implies len2 fits");
+    Ok(OsString::from_wide(&buf[..len]))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // This test doesn't really check anything other than that we can
+    // successfully query all kinds of computer names. We just print them out
+    // since there aren't really any properties about the names that we can
+    // assert.
+    //
+    // We specifically run this test in CI with --nocapture so that we can see
+    // the output.
+    #[test]
+    fn itworks() {
+        let kinds = [
+            ComputerNameKind::DnsDomain,
+            ComputerNameKind::DnsFullyQualified,
+            ComputerNameKind::DnsHostname,
+            ComputerNameKind::NetBios,
+            ComputerNameKind::PhysicalDnsDomain,
+            ComputerNameKind::PhysicalDnsFullyQualified,
+            ComputerNameKind::PhysicalDnsHostname,
+            ComputerNameKind::PhysicalNetBios,
+        ];
+        for kind in kinds {
+            let result = get_computer_name(kind);
+            let name = result.unwrap();
+            println!("{kind:?}: {name:?}");
+        }
+    }
+}

data/ext/cargo-vendor/winapi-util-0.1.9/src/win.rs

@@ -0,0 +1,246 @@
+use std::{
+    fs::File,
+    io,
+    os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle},
+    path::Path,
+    process,
+};
+
+/// A handle represents an owned and valid Windows handle to a file-like
+/// object.
+///
+/// When an owned handle is dropped, then the underlying raw handle is closed.
+/// To get a borrowed handle, use `HandleRef`.
+#[derive(Debug)]
+pub struct Handle(File);
+
+impl AsRawHandle for Handle {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0.as_raw_handle()
+    }
+}
+
+impl FromRawHandle for Handle {
+    unsafe fn from_raw_handle(handle: RawHandle) -> Handle {
+        Handle(File::from_raw_handle(handle))
+    }
+}
+
+impl IntoRawHandle for Handle {
+    fn into_raw_handle(self) -> RawHandle {
+        self.0.into_raw_handle()
+    }
+}
+
+impl Handle {
+    /// Create an owned handle to the given file.
+    ///
+    /// When the returned handle is dropped, the file is closed.
+    ///
+    /// Note that if the given file represents a handle to a directory, then
+    /// it is generally required that it have been opened with the
+    /// [`FILE_FLAG_BACKUP_SEMANTICS`] flag in order to use it in various
+    /// calls such as `information` or `typ`. To have this done automatically
+    /// for you, use the `from_path_any` constructor.
+    ///
+    /// [`FILE_FLAG_BACKUP_SEMANTICS`]: https://docs.microsoft.com/en-us/windows/desktop/api/FileAPI/nf-fileapi-createfilea
+    pub fn from_file(file: File) -> Handle {
+        Handle(file)
+    }
+
+    /// Open a file to the given file path, and return an owned handle to that
+    /// file.
+    ///
+    /// When the returned handle is dropped, the file is closed.
+    ///
+    /// If there was a problem opening the file, then the corresponding error
+    /// is returned.
+    pub fn from_path<P: AsRef<Path>>(path: P) -> io::Result<Handle> {
+        Ok(Handle::from_file(File::open(path)?))
+    }
+
+    /// Like `from_path`, but supports opening directory handles as well.
+    ///
+    /// If you use `from_path` on a directory, then subsequent queries using
+    /// that handle will fail.
+    pub fn from_path_any<P: AsRef<Path>>(path: P) -> io::Result<Handle> {
+        use std::fs::OpenOptions;
+        use std::os::windows::fs::OpenOptionsExt;
+        use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS;
+
+        let file = OpenOptions::new()
+            .read(true)
+            .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
+            .open(path)?;
+        Ok(Handle::from_file(file))
+    }
+
+    /// Return this handle as a standard `File` reference.
+    pub fn as_file(&self) -> &File {
+        &self.0
+    }
+
+    /// Return this handle as a standard `File` mutable reference.
+    pub fn as_file_mut(&mut self) -> &mut File {
+        &mut self.0
+    }
+}
+
+/// Represents a borrowed and valid Windows handle to a file-like object, such
+/// as stdin/stdout/stderr or an actual file.
+///
+/// When a borrowed handle is dropped, then the underlying raw handle is
+/// **not** closed. To get an owned handle, use `Handle`.
+#[derive(Debug)]
+pub struct HandleRef(HandleRefInner);
+
+/// The representation of a HandleRef, on which we define a custom Drop impl
+/// that avoids closing the underlying raw handle.
+#[derive(Debug)]
+struct HandleRefInner(Option<File>);
+
+impl Drop for HandleRefInner {
+    fn drop(&mut self) {
+        self.0.take().unwrap().into_raw_handle();
+    }
+}
+
+impl AsRawHandle for HandleRef {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.as_file().as_raw_handle()
+    }
+}
+
+impl Clone for HandleRef {
+    fn clone(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl HandleRef {
+    /// Create a borrowed handle to stdin.
+    ///
+    /// When the returned handle is dropped, stdin is not closed.
+    pub fn stdin() -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(io::stdin().as_raw_handle()) }
+    }
+
+    /// Create a handle to stdout.
+    ///
+    /// When the returned handle is dropped, stdout is not closed.
+    pub fn stdout() -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(io::stdout().as_raw_handle()) }
+    }
+
+    /// Create a handle to stderr.
+    ///
+    /// When the returned handle is dropped, stderr is not closed.
+    pub fn stderr() -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(io::stderr().as_raw_handle()) }
+    }
+
+    /// Create a borrowed handle to the given file.
+    ///
+    /// When the returned handle is dropped, the file is not closed.
+    pub fn from_file(file: &File) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(file.as_raw_handle()) }
+    }
+
+    /// Create a borrowed handle from the given raw handle.
+    ///
+    /// Note that unlike the `FromRawHandle` trait, this constructor does
+    /// **not** consume ownership of the given handle. That is, when the
+    /// borrowed handle created by this constructor is dropped, the underlying
+    /// handle will not be closed.
+    ///
+    /// # Safety
+    ///
+    /// This is unsafe because there is no guarantee that the given raw handle
+    /// is a valid handle. The caller must ensure this is true before invoking
+    /// this constructor.
+    pub unsafe fn from_raw_handle(handle: RawHandle) -> HandleRef {
+        HandleRef(HandleRefInner(Some(File::from_raw_handle(handle))))
+    }
+
+    /// Return this handle as a standard `File` reference.
+    pub fn as_file(&self) -> &File {
+        (self.0).0.as_ref().unwrap()
+    }
+
+    /// Return this handle as a standard `File` mutable reference.
+    pub fn as_file_mut(&mut self) -> &mut File {
+        (self.0).0.as_mut().unwrap()
+    }
+}
+
+/// Construct borrowed and valid Windows handles from file-like objects.
+pub trait AsHandleRef {
+    /// A borrowed handle that wraps the raw handle of the `Self` object.
+    fn as_handle_ref(&self) -> HandleRef;
+
+    /// A convenience routine for extracting a `HandleRef` from `Self`, and
+    /// then extracting a raw handle from the `HandleRef`.
+    fn as_raw(&self) -> RawHandle {
+        self.as_handle_ref().as_raw_handle()
+    }
+}
+
+impl<'a, T: AsHandleRef> AsHandleRef for &'a T {
+    fn as_handle_ref(&self) -> HandleRef {
+        (**self).as_handle_ref()
+    }
+}
+
+impl AsHandleRef for Handle {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for HandleRef {
+    fn as_handle_ref(&self) -> HandleRef {
+        self.clone()
+    }
+}
+
+impl AsHandleRef for File {
+    fn as_handle_ref(&self) -> HandleRef {
+        HandleRef::from_file(self)
+    }
+}
+
+impl AsHandleRef for io::Stdin {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for io::Stdout {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for io::Stderr {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for process::ChildStdin {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for process::ChildStdout {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}
+
+impl AsHandleRef for process::ChildStderr {
+    fn as_handle_ref(&self) -> HandleRef {
+        unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) }
+    }
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"266e92303f6640409fca37d47a202f8c1b3f7206b47457ff6d52684cb23447ef","LICENSE":"a6c48161a09acc75a0e25503bab66a731eb5fba5392ed4bb4743e4ba5085327a","build.rs":"d19fe439db9b48a8bf91af26001c20ea6010633133bc52a13679720187a7cf1b","src/abi/local.rs":"28a8dc818d9bc6d60e198b6502e6037dd76a0e84d59ed182177161485201bdc2","src/abi/mod.rs":"f1d8439c7d24748c564b58cd2716a4c7e033cb02e9452784db04fcbd0ff56e19","src/codegen/bounds.rs":"079c8bd8e49e60d8f37f8720706904875a30059f1f40946266a25864b4d1ee9f","src/codegen/builtin.rs":"534d652d00676e2be629145a94f7b08feebb0595e65b58351cdb26afacfba3f3","src/codegen/call.rs":"4b0cb498fe162eea3cc4ef17a85b59bf949f31398ebcea474d91d3b83e509094","src/codegen/context.rs":"2c4ff359b3219d2505ddfeaa6e4165ee6bbbbbb79ca0f11a521a16221e6a578b","src/codegen/control.rs":"8fec0db487c07429da6a06747e204efa85a5e931d8416b2bdc22e15c1ce10012","src/codegen/env.rs":"dc83f063fd2ec89b6e7290b02cf50a27b4ddfabe3cdfdccede837d94ef6f6c5b","src/codegen/mod.rs":"cb0b0fbb96c2e7e66a48e6274d307f624f894ef88256e2029c467b36daae9a59","src/frame/mod.rs":"0136acb5fa557f36b0149e891131e31b4450ab2f90dfa58f2b87734c29cbb80f","src/isa/aarch64/abi.rs":"32aaed937778c73d766ee85b13fd0210f706d3889204730ba80647383acb2d15","src/isa/aarch64/address.rs":"ca29a4192a25d06a30c67cd0eb86c03e5fef91325734eeac3705197c46960990","src/isa/aarch64/asm.rs":"48ab9e67bd4b8b861ffe151ccc757171d5afc6d48ddf9436f86802b44696ead8","src/isa/aarch64/masm.rs":"f0a9739834955db0aacd6f21b313ed7686366146ec398b0ab9bbb8bbadfda40c","src/isa/aarch64/mod.rs":"938c5a859f54c184eeff3ffc3a225decff811a5be3f31b505a73a1b68c8d1c3c","src/isa/aarch64/regs.rs":"2a4bb7afa2d2c42f391a524ab82960af67eb5a965da1d579e80b9fc6da446c5d","src/isa/mod.rs":"1d510bf60febcd07664a3436ab304d3884f8474ed6051423b4a29c30d3eb90c6","src/isa/reg.rs":"09e4abe918307f996bcb6df34531759253007480582ea89e3c7ae569907b632b","src/isa/x64/abi.rs":"3b5dbb2d7f68522d6c1659c38588c46f846b56957b57e7a811d38a14e2c08960","src/isa/x64/address.rs":"50245c51730ab31064628882d24155ba676803c29875ac9d226d081af9f6700d","src/isa/x64/asm.rs":"507591957a691897c728e2298742eff6653142359f21fbbdc66ba82cb951f211","src/isa/x64/masm.rs":"0d5736e35a2a3aa1ee69fee864218f5107383e4d5e746bf821c9cffacf4cc083","src/isa/x64/mod.rs":"58ee9a43fd750cbda62ece716d4e88796f813bd089c9766be82ec4ca71f6dbea","src/isa/x64/regs.rs":"d8725064e0c3ecd5531772707758f02332255258beecd36f5a06711a4fe83499","src/lib.rs":"ff6ec9d65c59b5f4d2d8561da13866c9c0bd5e5cccb106c61a35bd030f1339ce","src/masm.rs":"3c69dacdf7bcc2bc0241833d95668691ea8e9c20100d32f3867180b3515852b8","src/regalloc.rs":"c1da1ca1d8a8dfce6374d30094c0e8bd9be149234ed26c175cf14df0ad5339ab","src/regset.rs":"0c7d9eb05178333faeeaa1a784c5ff326ec60f858a78c149e592724119d0be25","src/stack.rs":"47a0d0cacc8bc9200404afb694b24f298c2bc20804151c991962e92cfb6764d8","src/visitor.rs":"f32c86aeb96b8515786ae1c6c3e8ef72e9c40e09546262b63b819c19654b2943"},"package":"2a41b67a37ea74e83c38ef495cc213aba73385236b1deee883dc869e835003b9"}

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

@@ -0,0 +1,87 @@
+# 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 = "winch-codegen"
+version = "0.21.2"
+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.110.2"
+features = [
+    "std",
+    "unwind",
+    "trace-log",
+    "unwind",
+]
+default-features = false
+
+[dependencies.gimli]
+version = "0.28.0"
+features = ["read"]
+default-features = false
+
+[dependencies.regalloc2]
+version = "0.9.3"
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.13"
+features = ["std"]
+
+[dependencies.wasmparser]
+version = "0.212.0"
+default-features = false
+
+[dependencies.wasmtime-cranelift]
+version = "=23.0.2"
+
+[dependencies.wasmtime-environ]
+version = "=23.0.2"
+
+[features]
+all-arch = [
+    "x64",
+    "arm64",
+]
+arm64 = ["cranelift-codegen/arm64"]
+x64 = ["cranelift-codegen/x86"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"