wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wasi-common-22.0.0/src/string_array.rs

@@ -0,0 +1,75 @@
+use crate::{Error, ErrorExt};
+use wiggle::{GuestMemory, GuestPtr};
+
+pub struct StringArray {
+    elems: Vec<String>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum StringArrayError {
+    #[error("Number of elements exceeds 2^32")]
+    NumberElements,
+    #[error("Element size exceeds 2^32")]
+    ElementSize,
+    #[error("Cumulative size exceeds 2^32")]
+    CumulativeSize,
+}
+
+impl StringArray {
+    pub fn new() -> Self {
+        StringArray { elems: Vec::new() }
+    }
+
+    pub fn push(&mut self, elem: String) -> Result<(), StringArrayError> {
+        if self.elems.len() + 1 > std::u32::MAX as usize {
+            return Err(StringArrayError::NumberElements);
+        }
+        if elem.as_bytes().len() + 1 > std::u32::MAX as usize {
+            return Err(StringArrayError::ElementSize);
+        }
+        if self.cumulative_size() as usize + elem.as_bytes().len() + 1 > std::u32::MAX as usize {
+            return Err(StringArrayError::CumulativeSize);
+        }
+        self.elems.push(elem);
+        Ok(())
+    }
+
+    pub fn number_elements(&self) -> u32 {
+        self.elems.len() as u32
+    }
+
+    pub fn cumulative_size(&self) -> u32 {
+        self.elems
+            .iter()
+            .map(|e| e.as_bytes().len() + 1)
+            .sum::<usize>() as u32
+    }
+
+    pub fn write_to_guest(
+        &self,
+        memory: &mut GuestMemory<'_>,
+        buffer: GuestPtr<u8>,
+        element_heads: GuestPtr<GuestPtr<u8>>,
+    ) -> Result<(), Error> {
+        let element_heads = element_heads.as_array(self.number_elements());
+        let buffer = buffer.as_array(self.cumulative_size());
+        let mut cursor = 0;
+        for (elem, head) in self.elems.iter().zip(element_heads.iter()) {
+            let bytes = elem.as_bytes();
+            let len = bytes.len() as u32;
+            {
+                let elem_buffer = buffer
+                    .get_range(cursor..(cursor + len))
+                    .ok_or(Error::invalid_argument())?; // Elements don't fit in buffer provided
+                memory.copy_from_slice(bytes, elem_buffer)?;
+            }
+            memory.write(
+                buffer.get(cursor + len).ok_or(Error::invalid_argument())?,
+                0,
+            )?; // 0 terminate
+            memory.write(head?, buffer.get(cursor).expect("already validated"))?;
+            cursor += len + 1;
+        }
+        Ok(())
+    }
+}

data/ext/cargo-vendor/wasi-common-22.0.0/src/sync/sched/windows.rs

@@ -0,0 +1,221 @@
+// The windows scheduler is unmaintained and due for a rewrite.
+//
+// Rather than use a polling mechanism for file read/write readiness,
+// it checks readiness just once, before sleeping for any timer subscriptions.
+// Checking stdin readiness uses a worker thread which, once started, lives for the
+// lifetime of the process.
+//
+// We suspect there are bugs in this scheduler, however, we have not
+// taken the time to improve it. See bug #2880.
+
+use crate::sched::subscription::{RwEventFlags, Subscription};
+use crate::{file::WasiFile, sched::Poll, Error, ErrorExt};
+use once_cell::sync::Lazy;
+use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
+use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+
+pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
+    poll_oneoff_(poll, wasi_file_is_stdin).await
+}
+
+pub async fn poll_oneoff_<'a>(
+    poll: &mut Poll<'a>,
+    file_is_stdin: impl Fn(&dyn WasiFile) -> bool,
+) -> Result<(), Error> {
+    if poll.is_empty() {
+        return Ok(());
+    }
+
+    let mut ready = false;
+    let waitmode = if let Some(t) = poll.earliest_clock_deadline() {
+        if let Some(duration) = t.duration_until() {
+            WaitMode::Timeout(duration)
+        } else {
+            WaitMode::Immediate
+        }
+    } else {
+        if ready {
+            WaitMode::Immediate
+        } else {
+            WaitMode::Infinite
+        }
+    };
+
+    let mut stdin_read_subs = Vec::new();
+    let mut immediate_reads = Vec::new();
+    let mut immediate_writes = Vec::new();
+    for s in poll.rw_subscriptions() {
+        match s {
+            Subscription::Read(r) => {
+                if file_is_stdin(r.file) {
+                    stdin_read_subs.push(r);
+                } else if r.file.pollable().is_some() {
+                    immediate_reads.push(r);
+                } else {
+                    return Err(Error::invalid_argument().context("file is not pollable"));
+                }
+            }
+            Subscription::Write(w) => {
+                if w.file.pollable().is_some() {
+                    immediate_writes.push(w);
+                } else {
+                    return Err(Error::invalid_argument().context("file is not pollable"));
+                }
+            }
+            Subscription::MonotonicClock { .. } => unreachable!(),
+        }
+    }
+
+    if !stdin_read_subs.is_empty() {
+        let state = STDIN_POLL
+            .lock()
+            .map_err(|_| Error::trap(anyhow::Error::msg("failed to take lock of STDIN_POLL")))?
+            .poll(waitmode)?;
+        for readsub in stdin_read_subs.into_iter() {
+            match state {
+                PollState::Ready => {
+                    readsub.complete(1, RwEventFlags::empty());
+                    ready = true;
+                }
+                PollState::NotReady | PollState::TimedOut => {}
+                PollState::Error(ref e) => {
+                    // Unfortunately, we need to deliver the Error to each of the
+                    // subscriptions, but there is no Clone on std::io::Error. So, we convert it to the
+                    // kind, and then back to std::io::Error, and finally to anyhow::Error.
+                    // When its time to turn this into an errno elsewhere, the error kind will
+                    // be inspected.
+                    let ekind = e.kind();
+                    let ioerror = std::io::Error::from(ekind);
+                    readsub.error(ioerror.into());
+                    ready = true;
+                }
+            }
+        }
+    }
+    for r in immediate_reads {
+        match r.file.num_ready_bytes() {
+            Ok(ready_bytes) => {
+                r.complete(ready_bytes, RwEventFlags::empty());
+                ready = true;
+            }
+            Err(e) => {
+                r.error(e);
+                ready = true;
+            }
+        }
+    }
+    for w in immediate_writes {
+        // Everything is always ready for writing, apparently?
+        w.complete(0, RwEventFlags::empty());
+        ready = true;
+    }
+
+    if !ready {
+        if let WaitMode::Timeout(duration) = waitmode {
+            thread::sleep(duration);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
+    f.as_any().is::<crate::sync::stdio::Stdin>()
+}
+
+enum PollState {
+    Ready,
+    NotReady, // Not ready, but did not wait
+    TimedOut, // Not ready, waited until timeout
+    Error(std::io::Error),
+}
+
+#[derive(Copy, Clone)]
+enum WaitMode {
+    Timeout(Duration),
+    Infinite,
+    Immediate,
+}
+
+struct StdinPoll {
+    request_tx: Sender<()>,
+    notify_rx: Receiver<PollState>,
+}
+
+static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
+
+impl StdinPoll {
+    pub fn new() -> Mutex<Self> {
+        let (request_tx, request_rx) = mpsc::channel();
+        let (notify_tx, notify_rx) = mpsc::channel();
+        thread::spawn(move || Self::event_loop(request_rx, notify_tx));
+        Mutex::new(StdinPoll {
+            request_tx,
+            notify_rx,
+        })
+    }
+
+    // This function should not be used directly.
+    // Correctness of this function crucially depends on the fact that
+    // mpsc::Receiver is !Sync.
+    fn poll(&self, wait_mode: WaitMode) -> Result<PollState, Error> {
+        match self.notify_rx.try_recv() {
+            // Clean up possibly unread result from previous poll.
+            Ok(_) | Err(TryRecvError::Empty) => {}
+            Err(TryRecvError::Disconnected) => {
+                return Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                )))
+            }
+        }
+
+        // Notify the worker thread to poll stdin
+        self.request_tx
+            .send(())
+            .map_err(|_| Error::trap(anyhow::Error::msg("request_tx channel closed")))?;
+
+        // Wait for the worker thread to send a readiness notification
+        match wait_mode {
+            WaitMode::Timeout(timeout) => match self.notify_rx.recv_timeout(timeout) {
+                Ok(r) => Ok(r),
+                Err(RecvTimeoutError::Timeout) => Ok(PollState::TimedOut),
+                Err(RecvTimeoutError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                ))),
+            },
+            WaitMode::Infinite => self
+                .notify_rx
+                .recv()
+                .map_err(|_| Error::trap(anyhow::Error::msg("StdinPoll notify_rx channel closed"))),
+            WaitMode::Immediate => match self.notify_rx.try_recv() {
+                Ok(r) => Ok(r),
+                Err(TryRecvError::Empty) => Ok(PollState::NotReady),
+                Err(TryRecvError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                ))),
+            },
+        }
+    }
+
+    fn event_loop(request_rx: Receiver<()>, notify_tx: Sender<PollState>) -> ! {
+        use std::io::BufRead;
+        loop {
+            // Wait on a request:
+            request_rx.recv().expect("request_rx channel");
+            // Wait for data to appear in stdin. If fill_buf returns any slice, it means
+            // that either:
+            // (a) there is some data in stdin, if non-empty,
+            // (b) EOF was received, if its empty
+            // Linux returns `POLLIN` in both cases, so we imitate this behavior.
+            let resp = match std::io::stdin().lock().fill_buf() {
+                Ok(_) => PollState::Ready,
+                Err(e) => PollState::Error(e),
+            };
+            // Notify about data in stdin. If the read on this channel has timed out, the
+            // next poller will have to clean the channel.
+            notify_tx.send(resp).expect("notify_tx channel");
+        }
+    }
+}

data/ext/cargo-vendor/wasi-common-22.0.0/src/tokio/file.rs

@@ -0,0 +1,247 @@
+use crate::tokio::block_on_dummy_executor;
+use crate::{
+    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
+    Error,
+};
+#[cfg(windows)]
+use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
+#[cfg(not(windows))]
+use io_lifetimes::AsFd;
+use std::any::Any;
+use std::borrow::Borrow;
+use std::io;
+
+pub struct File(crate::sync::file::File);
+
+impl File {
+    pub(crate) fn from_inner(file: crate::sync::file::File) -> Self {
+        File(file)
+    }
+    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
+        Self::from_inner(crate::sync::file::File::from_cap_std(file))
+    }
+}
+
+pub struct TcpListener(crate::sync::net::TcpListener);
+
+impl TcpListener {
+    pub(crate) fn from_inner(listener: crate::sync::net::TcpListener) -> Self {
+        TcpListener(listener)
+    }
+    pub fn from_cap_std(listener: cap_std::net::TcpListener) -> Self {
+        Self::from_inner(crate::sync::net::TcpListener::from_cap_std(listener))
+    }
+}
+
+pub struct TcpStream(crate::sync::net::TcpStream);
+
+impl TcpStream {
+    pub(crate) fn from_inner(stream: crate::sync::net::TcpStream) -> Self {
+        TcpStream(stream)
+    }
+    pub fn from_cap_std(stream: cap_std::net::TcpStream) -> Self {
+        Self::from_inner(crate::sync::net::TcpStream::from_cap_std(stream))
+    }
+}
+
+#[cfg(unix)]
+pub struct UnixListener(crate::sync::net::UnixListener);
+
+#[cfg(unix)]
+impl UnixListener {
+    pub(crate) fn from_inner(listener: crate::sync::net::UnixListener) -> Self {
+        UnixListener(listener)
+    }
+    pub fn from_cap_std(listener: cap_std::os::unix::net::UnixListener) -> Self {
+        Self::from_inner(crate::sync::net::UnixListener::from_cap_std(listener))
+    }
+}
+
+#[cfg(unix)]
+pub struct UnixStream(crate::sync::net::UnixStream);
+
+#[cfg(unix)]
+impl UnixStream {
+    fn from_inner(stream: crate::sync::net::UnixStream) -> Self {
+        UnixStream(stream)
+    }
+    pub fn from_cap_std(stream: cap_std::os::unix::net::UnixStream) -> Self {
+        Self::from_inner(crate::sync::net::UnixStream::from_cap_std(stream))
+    }
+}
+
+pub struct Stdin(crate::sync::stdio::Stdin);
+
+pub fn stdin() -> Stdin {
+    Stdin(crate::sync::stdio::stdin())
+}
+
+pub struct Stdout(crate::sync::stdio::Stdout);
+
+pub fn stdout() -> Stdout {
+    Stdout(crate::sync::stdio::stdout())
+}
+
+pub struct Stderr(crate::sync::stdio::Stderr);
+
+pub fn stderr() -> Stderr {
+    Stderr(crate::sync::stdio::stderr())
+}
+
+macro_rules! wasi_file_impl {
+    ($ty:ty) => {
+        #[wiggle::async_trait]
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            #[cfg(unix)]
+            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+                Some(self.0.as_fd())
+            }
+            #[cfg(windows)]
+            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+                Some(self.0.as_raw_handle_or_socket())
+            }
+            async fn datasync(&self) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.datasync())
+            }
+            async fn sync(&self) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.sync())
+            }
+            async fn get_filetype(&self) -> Result<FileType, Error> {
+                block_on_dummy_executor(|| self.0.get_filetype())
+            }
+            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+                block_on_dummy_executor(|| self.0.get_fdflags())
+            }
+            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.set_fdflags(fdflags))
+            }
+            async fn get_filestat(&self) -> Result<Filestat, Error> {
+                block_on_dummy_executor(|| self.0.get_filestat())
+            }
+            async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.set_filestat_size(size))
+            }
+            async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.advise(offset, len, advice))
+            }
+            async fn read_vectored<'a>(
+                &self,
+                bufs: &mut [io::IoSliceMut<'a>],
+            ) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.read_vectored(bufs))
+            }
+            async fn read_vectored_at<'a>(
+                &self,
+                bufs: &mut [io::IoSliceMut<'a>],
+                offset: u64,
+            ) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.read_vectored_at(bufs, offset))
+            }
+            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.write_vectored(bufs))
+            }
+            async fn write_vectored_at<'a>(
+                &self,
+                bufs: &[io::IoSlice<'a>],
+                offset: u64,
+            ) -> Result<u64, Error> {
+                if bufs.iter().map(|i| i.len()).sum::<usize>() == 0 {
+                    return Ok(0);
+                }
+                block_on_dummy_executor(move || self.0.write_vectored_at(bufs, offset))
+            }
+            async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.seek(pos))
+            }
+            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.peek(buf))
+            }
+            async fn set_times(
+                &self,
+                atime: Option<crate::SystemTimeSpec>,
+                mtime: Option<crate::SystemTimeSpec>,
+            ) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.set_times(atime, mtime))
+            }
+            fn num_ready_bytes(&self) -> Result<u64, Error> {
+                self.0.num_ready_bytes()
+            }
+            fn isatty(&self) -> bool {
+                self.0.isatty()
+            }
+
+            #[cfg(not(windows))]
+            async fn readable(&self) -> Result<(), Error> {
+                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
+                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
+                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
+                // async method to ensure this is the only Future which can access the RawFd during the
+                // lifetime of the AsyncFd.
+                use std::os::unix::io::AsRawFd;
+                use tokio::io::{unix::AsyncFd, Interest};
+                let rawfd = self.0.borrow().as_fd().as_raw_fd();
+                match AsyncFd::with_interest(rawfd, Interest::READABLE) {
+                    Ok(asyncfd) => {
+                        let _ = asyncfd.readable().await?;
+                        Ok(())
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+                        // if e is EPERM, this file isn't supported by epoll because it is immediately
+                        // available for reading:
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+
+            #[cfg(not(windows))]
+            async fn writable(&self) -> Result<(), Error> {
+                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
+                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
+                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
+                // async method to ensure this is the only Future which can access the RawFd during the
+                // lifetime of the AsyncFd.
+                use std::os::unix::io::AsRawFd;
+                use tokio::io::{unix::AsyncFd, Interest};
+                let rawfd = self.0.borrow().as_fd().as_raw_fd();
+                match AsyncFd::with_interest(rawfd, Interest::WRITABLE) {
+                    Ok(asyncfd) => {
+                        let _ = asyncfd.writable().await?;
+                        Ok(())
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+                        // if e is EPERM, this file isn't supported by epoll because it is immediately
+                        // available for writing:
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+
+            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
+                block_on_dummy_executor(|| self.0.sock_accept(fdflags))
+            }
+        }
+        #[cfg(windows)]
+        impl AsRawHandleOrSocket for $ty {
+            #[inline]
+            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+                self.0.borrow().as_raw_handle_or_socket()
+            }
+        }
+    };
+}
+
+wasi_file_impl!(File);
+wasi_file_impl!(TcpListener);
+wasi_file_impl!(TcpStream);
+#[cfg(unix)]
+wasi_file_impl!(UnixListener);
+#[cfg(unix)]
+wasi_file_impl!(UnixStream);
+wasi_file_impl!(Stdin);
+wasi_file_impl!(Stdout);
+wasi_file_impl!(Stderr);

data/ext/cargo-vendor/wasmparser-0.209.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"ae3a74125d3c3db19e4d8130007c1983bc03ae087fee0d01b361241e71e9dced","Cargo.toml":"49fea403ec32a6752eb642a219558a4dd9aee57bd20f9234bbefb67c898f90a1","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/benchmark.rs":"45ed921b97a85df370298186ff3b2ccea8c39664b12e0b4d475dea0e95f74118","examples/simple.rs":"e9eb076367cc0932e2a32651372defa4a27ef800f47fad28c0ef840ba8ea7e08","src/binary_reader.rs":"a48a6c1df676e175bae252e22882ec166323e00020132e4b1d8a220b3b05e0e7","src/collections/hash.rs":"fc2e621c5a72f77ed49fdef444ee35f5b628e2cc3defefcc5c3710e2490f740d","src/collections/index_map.rs":"d2b1de7d82393fe80b983a393a0d681f7a306edf16770efc525b75d5d24338f3","src/collections/index_map/detail.rs":"7fc067caa8ebbae593e551d4d08f04594496dac4c98d04539ba5cabee0f1e8cd","src/collections/index_map/tests.rs":"7761fda67a871bcef24579f0cbe4762e40fb8e7ca5147c67187da510c545c016","src/collections/index_set.rs":"f53bcbfbbeccd9bf62406f08565f5ac57af58cf962484a91d4efcd7431d37310","src/collections/map.rs":"b5e04ae1e763d98329c7bc70e3f6c7245ae554382cb45ca7e324709b74e32474","src/collections/mod.rs":"312a78533dcea4493c7897f0851f06dd39b44335225a5bb90fb0711c4afabefa","src/collections/set.rs":"3ed9baf1af23a4f0b0c47d76236fb12f9a052043c5d0473a8c0b441090246454","src/features.rs":"48fee71ab0f85007111006a2adcf2dbbc7685a577617660cfb47f1cec67d5f57","src/lib.rs":"1113ce41a7cc4e2934e3c9a70560b19c60e0777082fc03ddbf7f83df87538847","src/limits.rs":"49ec98313583bf024232f5e2c0f837c791c41382e0217e010e071c7495196a6f","src/parser.rs":"3edeab712c0e6b2b95f39c5e53c1cddac09a2e9b802ff1b59377299b82fafd59","src/readers.rs":"bdc52cd582eb270dfdcc90b667ff16f8ffccd33d6c0748de39fc24a5912b7c44","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"72f3339cb452c1b055bd080281fe4923d132c280da112fcd1182594811b87494","src/readers/component/canonicals.rs":"a6e7ceebb624e0fa6e740fe3a73446154e88b42c8dadee015870fd21e30a5e0f","src/readers/component/exports.rs":"177f05b11de2276a26842481b1260a8eface092f03736853a55f30d532994c28","src/readers/component/imports.rs":"dde8010917d8b6c996cf7d3af4d9376cbdf9f2739b247a8c2414499974cb6b2f","src/readers/component/instances.rs":"f6fc3094ff1db82265a1b4cbf5bedd6fc70788a69c2635bd35868e2f65dabacc","src/readers/component/names.rs":"4d4a965159bc5a2e788f5b1848700be5b5a7b9137b67bc14d7c692acb1f95765","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"988e2d8a00f0913fcc67c207df4aab48fe4a403f6567427feca0d195d218464e","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"29210720e08e3a558fd96ac857038c9b87732a265ff1bfbd7f0bf3312ea3e949","src/readers/core/code.rs":"fca8813d129f2a84c7ca257885dbe2c81c6cfb5f96b87b2caf78c128e1708f28","src/readers/core/coredumps.rs":"cee852752d95308e6ceb9e1e8bf0b6baf6e8cb3d7bf6fdbf86552bdb0c3251a4","src/readers/core/custom.rs":"56362a1c77af7a5d63d9c700edc22937ef020d27f071fef1d8bb0b598843b090","src/readers/core/data.rs":"6bd3223a3999c4896be259298e6f440ffd4e63c65ec4e502ebaf9ad12b529d7c","src/readers/core/dylink0.rs":"bd3de09ccd7a9b1dc1aacc3d4ebd7a70d31978c634c864aa2ca08a381ef24318","src/readers/core/elements.rs":"aa36b4b9fae50b51b6cc97baf68a522c4a1e382b3085022876a43e9c95db0658","src/readers/core/exports.rs":"50dc1ee51b73f03f24077f7c290bca756966563cedbad9e49d735d60f60c91db","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"beaf414927b8474dbee698bba2da8c7f2f149ca210a9ac3ec18ae83277598010","src/readers/core/imports.rs":"4d247e8cac0b3cef7425d93f7a7f2412b2ae8979da944080d565415499e27e87","src/readers/core/init.rs":"481b80204787cf51c47dadcec689f9249ab3c88efc3b3d17a692070b9bd3c711","src/readers/core/linking.rs":"9a330b8a6b4d378a452e2671e089dc2041bd1cdda8f0fd4dddc5bca54783456b","src/readers/core/memories.rs":"1db19b6bf640bb150be1ac84bf852687567f8c93d53f0ec66c47ab607676a4d9","src/readers/core/names.rs":"37dd9a9af4019e0a55ef0569a1dfc1586caa08d95eff258e33ecf2600ef09182","src/readers/core/operators.rs":"586a9b9f7e16ab366176b800f11270aa5d92f60721ff1ae54e89f6da936aa280","src/readers/core/producers.rs":"9a2131056411efb4e955fb874f2d798b7832c426d6711d7efe53e07a1f8e7b00","src/readers/core/reloc.rs":"3a4b0dc5700ae0df2943dc1e38c6113d091cd23b634cde42dfabb6119eddeb49","src/readers/core/tables.rs":"1376a26c608dd70e8231dd58face474ceeb830fd4f7735acc6f31cd8b9f62a0a","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"efa056c2161ec2c657b7c9ad97cc4ca537fd257f16eb62cbd87eff2e59682505","src/readers/core/types/matches.rs":"ff84f472b8589ef39cf513cbef2eedef9db071a9e74e1deddb4ef579097260ab","src/resources.rs":"375749dd1ad8f365fb3fd436f25f04139ec113101378e666ff85598ebd31b922","src/validator.rs":"c225942837109f8e1bc9e496d14e3e6a2b0726ff6b0d8d550e3a06874301c595","src/validator/component.rs":"e7f0570a208f91fe7f34f7f1c9b92dba18e22b1d11a0d3b4fcd2a90e98032baa","src/validator/core.rs":"76bbe6ccad709b75c078d9b579f343b9c5cd0358e8102462c944502518acc20d","src/validator/core/canonical.rs":"2edcf94d9d430169a197e0412580ba8243f3fdd2bfd0b306a7033bc58a85168c","src/validator/func.rs":"a4ca3d1c982c6f0240112be3e5e43d7606a305ae270d0114cf898c0f26f7eaaa","src/validator/names.rs":"b236631352c741e28efdbedeb0ec79e690bace38bca862c462cc85b0fd7732ed","src/validator/operators.rs":"f2192b69258ebc49bd4d33cbb080b2f0a954b5e350ca66654be5e836e3f9a87f","src/validator/types.rs":"96366f241311be05ee592ea22c99939cdd1d8f6eb6e2d9c763b5c683ffa48689","tests/big-module.rs":"2d956dedf1a9f0b1e976dd63c97d3707cd726da10166cad2f16ae33000ed13b3"},"package":"07035cc9a9b41e62d3bb3a3815a66ab87c993c06fe1cf6b2a3f2a18499d937db"}