wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmparser-0.111.0/src/readers/core/code.rs

@@ -0,0 +1,146 @@
+/* Copyright 2018 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::{BinaryReader, FromReader, OperatorsReader, Result, SectionLimited, ValType};
+use std::ops::Range;
+
+/// A reader for the code section of a WebAssembly module.
+pub type CodeSectionReader<'a> = SectionLimited<'a, FunctionBody<'a>>;
+
+/// Represents a WebAssembly function body.
+#[derive(Debug, Clone)]
+pub struct FunctionBody<'a> {
+    reader: BinaryReader<'a>,
+}
+
+impl<'a> FunctionBody<'a> {
+    /// Constructs a new `FunctionBody` for the given data and offset.
+    pub fn new(offset: usize, data: &'a [u8]) -> Self {
+        Self {
+            reader: BinaryReader::new_with_offset(data, offset),
+        }
+    }
+
+    /// Whether or not to allow 64-bit memory arguments in the
+    /// function body.
+    ///
+    /// This is intended to be `true` when support for the memory64
+    /// WebAssembly proposal is also enabled.
+    pub fn allow_memarg64(&mut self, allow: bool) {
+        self.reader.allow_memarg64(allow);
+    }
+
+    /// Gets a binary reader for this function body.
+    pub fn get_binary_reader(&self) -> BinaryReader<'a> {
+        self.reader.clone()
+    }
+
+    fn skip_locals(reader: &mut BinaryReader) -> Result<()> {
+        let count = reader.read_var_u32()?;
+        for _ in 0..count {
+            reader.read_var_u32()?;
+            reader.read::<ValType>()?;
+        }
+        Ok(())
+    }
+
+    /// Gets the locals reader for this function body.
+    pub fn get_locals_reader(&self) -> Result<LocalsReader<'a>> {
+        let mut reader = self.reader.clone();
+        let count = reader.read_var_u32()?;
+        Ok(LocalsReader { reader, count })
+    }
+
+    /// Gets the operators reader for this function body.
+    pub fn get_operators_reader(&self) -> Result<OperatorsReader<'a>> {
+        let mut reader = self.reader.clone();
+        Self::skip_locals(&mut reader)?;
+        Ok(OperatorsReader::new(reader))
+    }
+
+    /// Gets the range of the function body.
+    pub fn range(&self) -> Range<usize> {
+        self.reader.range()
+    }
+}
+
+impl<'a> FromReader<'a> for FunctionBody<'a> {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let reader = reader.read_reader("function body extends past end of the code section")?;
+        Ok(FunctionBody { reader })
+    }
+}
+
+/// A reader for a function body's locals.
+pub struct LocalsReader<'a> {
+    reader: BinaryReader<'a>,
+    count: u32,
+}
+
+impl<'a> LocalsReader<'a> {
+    /// Gets the count of locals in the function body.
+    pub fn get_count(&self) -> u32 {
+        self.count
+    }
+
+    /// Gets the original position of the reader.
+    pub fn original_position(&self) -> usize {
+        self.reader.original_position()
+    }
+
+    /// Reads an item from the reader.
+    pub fn read(&mut self) -> Result<(u32, ValType)> {
+        let count = self.reader.read()?;
+        let value_type = self.reader.read()?;
+        Ok((count, value_type))
+    }
+}
+
+impl<'a> IntoIterator for LocalsReader<'a> {
+    type Item = Result<(u32, ValType)>;
+    type IntoIter = LocalsIterator<'a>;
+    fn into_iter(self) -> Self::IntoIter {
+        let count = self.count;
+        LocalsIterator {
+            reader: self,
+            left: count,
+            err: false,
+        }
+    }
+}
+
+/// An iterator over locals in a function body.
+pub struct LocalsIterator<'a> {
+    reader: LocalsReader<'a>,
+    left: u32,
+    err: bool,
+}
+
+impl<'a> Iterator for LocalsIterator<'a> {
+    type Item = Result<(u32, ValType)>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.err || self.left == 0 {
+            return None;
+        }
+        let result = self.reader.read();
+        self.err = result.is_err();
+        self.left -= 1;
+        Some(result)
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let count = self.reader.get_count() as usize;
+        (count, Some(count))
+    }
+}

data/ext/cargo-vendor/wasmparser-0.111.0/src/readers/core/coredumps.rs

@@ -0,0 +1,243 @@
+use crate::{BinaryReader, FromReader, Result};
+
+/// The data portion of a custom section representing a core dump. Per the
+/// tool-conventions repo, this section just specifies the executable name that
+/// the core dump came from while the rest of the core dump information is
+/// contained in a corestack custom section
+///
+/// # Examples
+///
+/// ```
+/// use wasmparser::{ BinaryReader, CoreDumpSection, FromReader, Result };
+/// let data: &[u8] = &[0x00, 0x09, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x77, 0x61,
+///      0x73, 0x6d];
+/// let mut reader = BinaryReader::new(data);
+/// let core = CoreDumpSection::from_reader(&mut reader).unwrap();
+/// assert!(core.name == "test.wasm")
+/// ```
+pub struct CoreDumpSection<'a> {
+    /// The name of the process that created the core dump
+    pub name: &'a str,
+}
+
+impl<'a> FromReader<'a> for CoreDumpSection<'a> {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        if reader.read_u8()? != 0 {
+            bail!(pos, "invalid start byte for core dump name");
+        }
+        let name = reader.read_string()?;
+        Ok(CoreDumpSection { name })
+    }
+}
+
+/// The data portion of a "coremodules" custom section. This contains a vec of
+/// module names that will be referenced by index by other coredump sections.
+///
+/// # Example
+///
+/// ```
+/// use wasmparser::{ BinaryReader, CoreDumpModulesSection, FromReader, Result };
+/// let data: &[u8] = &[0x01, 0x00, 0x04, 0x74, 0x65, 0x73, 0x74];
+/// let mut reader = BinaryReader::new(data);
+/// let modules_section = CoreDumpModulesSection::from_reader(&mut reader).unwrap();
+/// assert!(modules_section.modules[0] == "test")
+/// ```
+#[derive(Debug)]
+pub struct CoreDumpModulesSection<'a> {
+    /// A list of module names, which may be URLs, file paths, or other
+    /// identifiers for the module.
+    pub modules: Vec<&'a str>,
+}
+
+impl<'a> FromReader<'a> for CoreDumpModulesSection<'a> {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        let mut modules = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            if reader.read_u8()? != 0 {
+                bail!(pos, "invalid start byte for coremodule");
+            }
+            modules.push(reader.read_string()?);
+        }
+        Ok(CoreDumpModulesSection { modules })
+    }
+}
+/// A custom section representing the instances involved in a given coredump
+pub struct CoreDumpInstancesSection {
+    /// The instances for the coredump
+    pub instances: Vec<CoreDumpInstance>,
+}
+
+impl<'a> FromReader<'a> for CoreDumpInstancesSection {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let mut instances = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            instances.push(CoreDumpInstance::from_reader(reader)?);
+        }
+        Ok(CoreDumpInstancesSection { instances })
+    }
+}
+
+/// A single instance from a coredump instances section
+pub struct CoreDumpInstance {
+    /// The module that this is an instance of, as an index into a "coremodules"
+    /// section.
+    pub module_index: u32,
+
+    /// Which of the coredump's memories are this instance's memories, via
+    /// indexing into the memory index space.
+    pub memories: Vec<u32>,
+
+    /// Which of the coredump's globals are this instance's globals, via
+    /// indexing into the global index space.
+    pub globals: Vec<u32>,
+}
+
+impl<'a> FromReader<'a> for CoreDumpInstance {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        if reader.read_u8()? != 0 {
+            bail!(pos, "invalid start byte for core dump instance");
+        }
+        let module_index = reader.read_var_u32()?;
+        let mut memories = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            memories.push(reader.read_var_u32()?);
+        }
+        let mut globals = vec![];
+
+        for _ in 0..reader.read_var_u32()? {
+            globals.push(reader.read_var_u32()?);
+        }
+
+        Ok(CoreDumpInstance {
+            module_index,
+            memories,
+            globals,
+        })
+    }
+}
+
+/// The data portion of a custom section representing a core dump stack. The
+/// structure of this follows the coredump spec in the tool-conventions repo
+///
+/// # Examples
+///
+/// ```
+/// let data: &[u8] = &[0x00, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x01, 0x00, 0x04,
+///     0x2a, 0x33, 0x01, 0x7f, 0x01, 0x01, 0x7f, 0x02];
+/// use wasmparser::{ BinaryReader, CoreDumpStackSection, FromReader };
+/// let mut reader = BinaryReader::new(data);
+/// let corestack = CoreDumpStackSection::from_reader(&mut reader).unwrap();
+/// assert!(corestack.name == "main");
+/// assert!(corestack.frames.len() == 1);
+/// let frame = &corestack.frames[0];
+/// assert!(frame.instanceidx == 4);
+/// assert!(frame.funcidx == 42);
+/// assert!(frame.codeoffset == 51);
+/// assert!(frame.locals.len() == 1);
+/// assert!(frame.stack.len() == 1);
+/// ```
+pub struct CoreDumpStackSection<'a> {
+    /// The thread name
+    pub name: &'a str,
+    /// The stack frames for the core dump
+    pub frames: Vec<CoreDumpStackFrame>,
+}
+
+impl<'a> FromReader<'a> for CoreDumpStackSection<'a> {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        if reader.read_u8()? != 0 {
+            bail!(pos, "invalid start byte for core dump stack name");
+        }
+        let name = reader.read_string()?;
+        let mut frames = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            frames.push(CoreDumpStackFrame::from_reader(reader)?);
+        }
+        Ok(CoreDumpStackSection {
+            name: name,
+            frames: frames,
+        })
+    }
+}
+
+/// A single stack frame from a core dump
+#[derive(Debug)]
+pub struct CoreDumpStackFrame {
+    /// The instance that this stack frame belongs to.
+    pub instanceidx: u32,
+    /// The function index in the module
+    pub funcidx: u32,
+    /// The instruction's offset relative to the function's start
+    pub codeoffset: u32,
+    /// The locals for this stack frame (including function parameters)
+    pub locals: Vec<CoreDumpValue>,
+    /// The values on the stack
+    pub stack: Vec<CoreDumpValue>,
+}
+
+impl<'a> FromReader<'a> for CoreDumpStackFrame {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        if reader.read_u8()? != 0 {
+            bail!(pos, "invalid start byte for core dump stack frame");
+        }
+        let instanceidx = reader.read_var_u32()?;
+        let funcidx = reader.read_var_u32()?;
+        let codeoffset = reader.read_var_u32()?;
+        let mut locals = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            locals.push(CoreDumpValue::from_reader(reader)?);
+        }
+        let mut stack = vec![];
+        for _ in 0..reader.read_var_u32()? {
+            stack.push(CoreDumpValue::from_reader(reader)?);
+        }
+
+        Ok(CoreDumpStackFrame {
+            instanceidx,
+            funcidx,
+            codeoffset,
+            locals,
+            stack,
+        })
+    }
+}
+
+/// Local and stack values are encoded using one byte for the type (similar to
+/// Wasm's Number Types) followed by bytes representing the actual value
+/// See the tool-conventions repo for more details.
+#[derive(Clone, Debug)]
+pub enum CoreDumpValue {
+    /// A missing value (usually missing because it was optimized out)
+    Missing,
+    /// An i32 value
+    I32(i32),
+    /// An i64 value
+    I64(i64),
+    /// An f32 value
+    F32(f32),
+    /// An f64 value
+    F64(f64),
+}
+
+impl<'a> FromReader<'a> for CoreDumpValue {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let pos = reader.original_position();
+        match reader.read_u8()? {
+            0x01 => Ok(CoreDumpValue::Missing),
+            0x7F => Ok(CoreDumpValue::I32(reader.read_var_i32()?)),
+            0x7E => Ok(CoreDumpValue::I64(reader.read_var_i64()?)),
+            0x7D => Ok(CoreDumpValue::F32(f32::from_bits(
+                reader.read_f32()?.bits(),
+            ))),
+            0x7C => Ok(CoreDumpValue::F64(f64::from_bits(
+                reader.read_f64()?.bits(),
+            ))),
+            _ => bail!(pos, "invalid CoreDumpValue type"),
+        }
+    }
+}

data/ext/cargo-vendor/wasmparser-0.111.0/src/readers/core/custom.rs

@@ -0,0 +1,63 @@
+use crate::{BinaryReader, Result};
+use std::ops::Range;
+
+/// A reader for custom sections of a WebAssembly module.
+#[derive(Clone)]
+pub struct CustomSectionReader<'a> {
+    // NB: these fields are public to the crate to make testing easier.
+    pub(crate) name: &'a str,
+    pub(crate) data_offset: usize,
+    pub(crate) data: &'a [u8],
+    pub(crate) range: Range<usize>,
+}
+
+impl<'a> CustomSectionReader<'a> {
+    /// Constructs a new `CustomSectionReader` for the given data and offset.
+    pub fn new(data: &'a [u8], offset: usize) -> Result<CustomSectionReader<'a>> {
+        let mut reader = BinaryReader::new_with_offset(data, offset);
+        let name = reader.read_string()?;
+        let data_offset = reader.original_position();
+        let data = reader.remaining_buffer();
+        let range = reader.range();
+        Ok(CustomSectionReader {
+            name,
+            data_offset,
+            data,
+            range,
+        })
+    }
+
+    /// The name of the custom section.
+    pub fn name(&self) -> &'a str {
+        self.name
+    }
+
+    /// The offset, relative to the start of the original module or component,
+    /// that the `data` payload for this custom section starts at.
+    pub fn data_offset(&self) -> usize {
+        self.data_offset
+    }
+
+    /// The actual contents of the custom section.
+    pub fn data(&self) -> &'a [u8] {
+        self.data
+    }
+
+    /// The range of bytes that specify this whole custom section (including
+    /// both the name of this custom section and its data) specified in
+    /// offsets relative to the start of the byte stream.
+    pub fn range(&self) -> Range<usize> {
+        self.range.clone()
+    }
+}
+
+impl<'a> std::fmt::Debug for CustomSectionReader<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CustomSectionReader")
+            .field("name", &self.name)
+            .field("data_offset", &self.data_offset)
+            .field("data", &"...")
+            .field("range", &self.range)
+            .finish()
+    }
+}

data/ext/cargo-vendor/wasmparser-0.111.0/src/readers/core/data.rs

@@ -0,0 +1,96 @@
+/* Copyright 2018 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::{BinaryReader, BinaryReaderError, ConstExpr, FromReader, Result, SectionLimited};
+use std::ops::Range;
+
+/// Represents a data segment in a core WebAssembly module.
+#[derive(Debug, Clone)]
+pub struct Data<'a> {
+    /// The kind of data segment.
+    pub kind: DataKind<'a>,
+    /// The data of the data segment.
+    pub data: &'a [u8],
+    /// The range of the data segment.
+    pub range: Range<usize>,
+}
+
+/// The kind of data segment.
+#[derive(Debug, Copy, Clone)]
+pub enum DataKind<'a> {
+    /// The data segment is passive.
+    Passive,
+    /// The data segment is active.
+    Active {
+        /// The memory index for the data segment.
+        memory_index: u32,
+        /// The initialization expression for the data segment.
+        offset_expr: ConstExpr<'a>,
+    },
+}
+
+/// A reader for the data section of a WebAssembly module.
+pub type DataSectionReader<'a> = SectionLimited<'a, Data<'a>>;
+
+impl<'a> FromReader<'a> for Data<'a> {
+    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let segment_start = reader.original_position();
+
+        // The current handling of the flags is largely specified in the `bulk-memory` proposal,
+        // which at the time this comment is written has been merged to the main specification
+        // draft.
+        //
+        // Notably, this proposal allows multiple different encodings of the memory index 0. `00`
+        // and `02 00` are both valid ways to specify the 0-th memory. However it also makes
+        // another encoding of the 0-th memory `80 00` no longer valid.
+        //
+        // We, however maintain this by parsing `flags` as a LEB128 integer. In that case, `80 00`
+        // encoding is parsed out as `0` and is therefore assigned a `memidx` 0, even though the
+        // current specification draft does not allow for this.
+        //
+        // See also https://github.com/WebAssembly/spec/issues/1439
+        let flags = reader.read_var_u32()?;
+        let kind = match flags {
+            1 => DataKind::Passive,
+            0 | 2 => {
+                let memory_index = if flags == 0 {
+                    0
+                } else {
+                    reader.read_var_u32()?
+                };
+                let offset_expr = reader.read()?;
+                DataKind::Active {
+                    memory_index,
+                    offset_expr,
+                }
+            }
+            _ => {
+                return Err(BinaryReaderError::new(
+                    "invalid flags byte in data segment",
+                    segment_start,
+                ));
+            }
+        };
+
+        let data = reader.read_reader(
+            "unexpected end of section or function: data segment extends past end of the section",
+        )?;
+        Ok(Data {
+            kind,
+            data: data.remaining_buffer(),
+            range: segment_start..data.range().end,
+        })
+    }
+}

data/ext/cargo-vendor/wasmparser-0.111.0/src/readers/core/dylink0.rs

@@ -0,0 +1,132 @@
+use crate::{BinaryReader, Result, Subsection, Subsections};
+use std::ops::Range;
+
+/// Parser for the dynamic linking `dylink.0` custom section.
+///
+/// This format is currently defined upstream at
+/// <https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md>.
+pub type Dylink0SectionReader<'a> = Subsections<'a, Dylink0Subsection<'a>>;
+
+const WASM_DYLINK_MEM_INFO: u8 = 1;
+const WASM_DYLINK_NEEDED: u8 = 2;
+const WASM_DYLINK_EXPORT_INFO: u8 = 3;
+const WASM_DYLINK_IMPORT_INFO: u8 = 4;
+
+#[allow(missing_docs)]
+pub const WASM_SYM_BINDING_WEAK: u32 = 1 << 0;
+#[allow(missing_docs)]
+pub const WASM_SYM_BINDING_LOCAL: u32 = 1 << 1;
+#[allow(missing_docs)]
+pub const WASM_SYM_VISIBILITY_HIDDEN: u32 = 1 << 2;
+#[allow(missing_docs)]
+pub const WASM_SYM_UNDEFINED: u32 = 1 << 4;
+#[allow(missing_docs)]
+pub const WASM_SYM_EXPORTED: u32 = 1 << 5;
+#[allow(missing_docs)]
+pub const WASM_SYM_EXPLICIT_NAME: u32 = 1 << 6;
+#[allow(missing_docs)]
+pub const WASM_SYM_NO_STRIP: u32 = 1 << 7;
+
+/// Represents a `WASM_DYLINK_MEM_INFO` field
+#[derive(Debug, Copy, Clone)]
+pub struct MemInfo {
+    /// Size of the memory area the loader should reserve for the module, which
+    /// will begin at `env.__memory_base`.
+    pub memory_size: u32,
+
+    /// The required alignment of the memory area, in bytes, encoded as a power
+    /// of 2.
+    pub memory_alignment: u32,
+
+    /// Size of the table area the loader should reserve for the module, which
+    /// will begin at `env.__table_base`.
+    pub table_size: u32,
+
+    /// The required alignment of the table area, in elements, encoded as a
+    /// power of 2.
+    pub table_alignment: u32,
+}
+
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub struct ExportInfo<'a> {
+    pub name: &'a str,
+
+    /// Note that these flags correspond to those described in
+    /// <https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md>
+    /// with the `WASM_SYM_*` prefix.
+    pub flags: u32,
+}
+
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub struct ImportInfo<'a> {
+    pub module: &'a str,
+    pub field: &'a str,
+
+    /// Note that these flags correspond to those described in
+    /// <https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md>
+    /// with the `WASM_SYM_*` prefix.
+    pub flags: u32,
+}
+
+/// Possible subsections of the `dylink.0` custom section.
+#[derive(Debug)]
+#[allow(missing_docs)]
+pub enum Dylink0Subsection<'a> {
+    MemInfo(MemInfo),
+    Needed(Vec<&'a str>),
+    ExportInfo(Vec<ExportInfo<'a>>),
+    ImportInfo(Vec<ImportInfo<'a>>),
+    Unknown {
+        ty: u8,
+        data: &'a [u8],
+        range: Range<usize>,
+    },
+}
+
+impl<'a> Subsection<'a> for Dylink0Subsection<'a> {
+    fn from_reader(id: u8, mut reader: BinaryReader<'a>) -> Result<Self> {
+        let data = reader.remaining_buffer();
+        let offset = reader.original_position();
+        Ok(match id {
+            WASM_DYLINK_MEM_INFO => Self::MemInfo(MemInfo {
+                memory_size: reader.read_var_u32()?,
+                memory_alignment: reader.read_var_u32()?,
+                table_size: reader.read_var_u32()?,
+                table_alignment: reader.read_var_u32()?,
+            }),
+            WASM_DYLINK_NEEDED => Self::Needed(
+                (0..reader.read_var_u32()?)
+                    .map(|_| reader.read_string())
+                    .collect::<Result<_, _>>()?,
+            ),
+            WASM_DYLINK_EXPORT_INFO => Self::ExportInfo(
+                (0..reader.read_var_u32()?)
+                    .map(|_| {
+                        Ok(ExportInfo {
+                            name: reader.read_string()?,
+                            flags: reader.read_var_u32()?,
+                        })
+                    })
+                    .collect::<Result<_, _>>()?,
+            ),
+            WASM_DYLINK_IMPORT_INFO => Self::ImportInfo(
+                (0..reader.read_var_u32()?)
+                    .map(|_| {
+                        Ok(ImportInfo {
+                            module: reader.read_string()?,
+                            field: reader.read_string()?,
+                            flags: reader.read_var_u32()?,
+                        })
+                    })
+                    .collect::<Result<_, _>>()?,
+            ),
+            ty => Self::Unknown {
+                ty,
+                data,
+                range: offset..offset + data.len(),
+            },
+        })
+    }
+}