wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/cranelift-wasm-0.109.0/src/heap.rs

@@ -1,116 +0,0 @@
-//! Heaps to implement WebAssembly linear memories.
-
-use cranelift_codegen::ir::{GlobalValue, MemoryType, Type};
-use cranelift_entity::entity_impl;
-
-/// An opaque reference to a [`HeapData`][crate::HeapData].
-///
-/// While the order is stable, it is arbitrary.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Serialize, serde_derive::Deserialize)
-)]
-pub struct Heap(u32);
-entity_impl!(Heap, "heap");
-
-/// A heap implementing a WebAssembly linear memory.
-///
-/// Code compiled from WebAssembly runs in a sandbox where it can't access all
-/// process memory. Instead, it is given a small set of memory areas to work in,
-/// and all accesses are bounds checked. `cranelift-wasm` models this through
-/// the concept of *heaps*.
-///
-/// Heap addresses can be smaller than the native pointer size, for example
-/// unsigned `i32` offsets on a 64-bit architecture.
-///
-/// A heap appears as three consecutive ranges of address space:
-///
-/// 1. The *mapped pages* are the accessible memory range in the heap. A heap
-///    may have a minimum guaranteed size which means that some mapped pages are
-///    always present.
-///
-/// 2. The *unmapped pages* is a possibly empty range of address space that may
-///    be mapped in the future when the heap is grown. They are addressable but
-///    not accessible.
-///
-/// 3. The *offset-guard pages* is a range of address space that is guaranteed
-///    to always cause a trap when accessed. It is used to optimize bounds
-///    checking for heap accesses with a shared base pointer. They are
-///    addressable but not accessible.
-///
-/// The *heap bound* is the total size of the mapped and unmapped pages. This is
-/// the bound that `heap_addr` checks against. Memory accesses inside the heap
-/// bounds can trap if they hit an unmapped page (which is not accessible).
-///
-/// Two styles of heaps are supported, *static* and *dynamic*. They behave
-/// differently when resized.
-///
-/// #### Static heaps
-///
-/// A *static heap* starts out with all the address space it will ever need, so
-/// it never moves to a different address. At the base address is a number of
-/// mapped pages corresponding to the heap's current size. Then follows a number
-/// of unmapped pages where the heap can grow up to its maximum size. After the
-/// unmapped pages follow the offset-guard pages which are also guaranteed to
-/// generate a trap when accessed.
-///
-/// #### Dynamic heaps
-///
-/// A *dynamic heap* can be relocated to a different base address when it is
-/// resized, and its bound can move dynamically. The offset-guard pages move
-/// when the heap is resized. The bound of a dynamic heap is stored in a global
-/// value.
-#[derive(Clone, PartialEq, Hash)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Serialize, serde_derive::Deserialize)
-)]
-pub struct HeapData {
-    /// The address of the start of the heap's storage.
-    pub base: GlobalValue,
-
-    /// Guaranteed minimum heap size in bytes. Heap accesses before `min_size`
-    /// don't need bounds checking.
-    pub min_size: u64,
-
-    /// The maximum heap size in bytes.
-    ///
-    /// Heap accesses larger than this will always trap.
-    pub max_size: Option<u64>,
-
-    /// Size in bytes of the offset-guard pages following the heap.
-    pub offset_guard_size: u64,
-
-    /// Heap style, with additional style-specific info.
-    pub style: HeapStyle,
-
-    /// The index type for the heap.
-    pub index_type: Type,
-
-    /// The memory type for the pointed-to memory, if using proof-carrying code.
-    pub memory_type: Option<MemoryType>,
-}
-
-/// Style of heap including style-specific information.
-#[derive(Clone, PartialEq, Hash)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Serialize, serde_derive::Deserialize)
-)]
-pub enum HeapStyle {
-    /// A dynamic heap can be relocated to a different base address when it is
-    /// grown.
-    Dynamic {
-        /// Global value providing the current bound of the heap in bytes.
-        bound_gv: GlobalValue,
-    },
-
-    /// A static heap has a fixed base address and a number of not-yet-allocated
-    /// pages before the offset-guard pages.
-    Static {
-        /// Heap bound in bytes. The offset-guard pages are allocated after the
-        /// bound.
-        bound: u64,
-    },
-}

data/ext/cargo-vendor/cranelift-wasm-0.109.0/src/sections_translator.rs

@@ -1,343 +0,0 @@
-//! Helper functions to gather information for each of the non-function sections of a
-//! WebAssembly module.
-//!
-//! The code of these helper functions is straightforward since they only read metadata
-//! about linear memories, tables, globals, etc. and store them for later use.
-//!
-//! The special case of the initialize expressions for table elements offsets or global variables
-//! is handled, according to the semantics of WebAssembly, to only specific expressions that are
-//! interpreted on the fly.
-use crate::environ::ModuleEnvironment;
-use crate::wasm_unsupported;
-use crate::{
-    DataIndex, ElemIndex, FuncIndex, GlobalIndex, Memory, MemoryIndex, TableIndex, Tag, TagIndex,
-    TypeIndex, WasmError, WasmResult,
-};
-use cranelift_entity::packed_option::ReservedValue;
-use cranelift_entity::EntityRef;
-use std::boxed::Box;
-use std::vec::Vec;
-use wasmparser::{
-    Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind, ElementSectionReader,
-    Export, ExportSectionReader, ExternalKind, FunctionSectionReader, GlobalSectionReader,
-    ImportSectionReader, MemorySectionReader, MemoryType, Operator, TableSectionReader,
-    TagSectionReader, TagType, TypeRef, TypeSectionReader,
-};
-use wasmtime_types::ConstExpr;
-
-fn memory(ty: MemoryType) -> Memory {
-    Memory {
-        minimum: ty.initial,
-        maximum: ty.maximum,
-        shared: ty.shared,
-        memory64: ty.memory64,
-    }
-}
-
-fn tag(e: TagType) -> Tag {
-    match e.kind {
-        wasmparser::TagKind::Exception => Tag {
-            ty: TypeIndex::from_u32(e.func_type_idx),
-        },
-    }
-}
-
-/// Parses the Type section of the wasm module.
-pub fn parse_type_section<'a>(
-    types: TypeSectionReader<'a>,
-    environ: &mut dyn ModuleEnvironment<'a>,
-) -> WasmResult<()> {
-    let count = types.count();
-    environ.reserve_types(count)?;
-
-    for ty in types.into_iter_err_on_gc_types() {
-        let ty = environ.convert_func_type(&ty?);
-        environ.declare_type_func(ty)?;
-    }
-    Ok(())
-}
-
-/// Parses the Import section of the wasm module.
-pub fn parse_import_section<'data>(
-    imports: ImportSectionReader<'data>,
-    environ: &mut dyn ModuleEnvironment<'data>,
-) -> WasmResult<()> {
-    environ.reserve_imports(imports.count())?;
-
-    for entry in imports {
-        let import = entry?;
-        match import.ty {
-            TypeRef::Func(sig) => {
-                environ.declare_func_import(
-                    TypeIndex::from_u32(sig),
-                    import.module,
-                    import.name,
-                )?;
-            }
-            TypeRef::Memory(ty) => {
-                environ.declare_memory_import(memory(ty), import.module, import.name)?;
-            }
-            TypeRef::Tag(e) => {
-                environ.declare_tag_import(tag(e), import.module, import.name)?;
-            }
-            TypeRef::Global(ty) => {
-                let ty = environ.convert_global_type(&ty);
-                environ.declare_global_import(ty, import.module, import.name)?;
-            }
-            TypeRef::Table(ty) => {
-                let ty = environ.convert_table_type(&ty)?;
-                environ.declare_table_import(ty, import.module, import.name)?;
-            }
-        }
-    }
-
-    environ.finish_imports()?;
-    Ok(())
-}
-
-/// Parses the Function section of the wasm module.
-pub fn parse_function_section(
-    functions: FunctionSectionReader,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    let num_functions = functions.count();
-    if num_functions == std::u32::MAX {
-        // We reserve `u32::MAX` for our own use in cranelift-entity.
-        return Err(WasmError::ImplLimitExceeded);
-    }
-
-    environ.reserve_func_types(num_functions)?;
-
-    for entry in functions {
-        let sigindex = entry?;
-        environ.declare_func_type(TypeIndex::from_u32(sigindex))?;
-    }
-
-    Ok(())
-}
-
-/// Parses the Table section of the wasm module.
-pub fn parse_table_section(
-    tables: TableSectionReader,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    environ.reserve_tables(tables.count())?;
-
-    for entry in tables {
-        let ty = environ.convert_table_type(&entry?.ty)?;
-        environ.declare_table(ty)?;
-    }
-
-    Ok(())
-}
-
-/// Parses the Memory section of the wasm module.
-pub fn parse_memory_section(
-    memories: MemorySectionReader,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    environ.reserve_memories(memories.count())?;
-
-    for entry in memories {
-        let memory = memory(entry?);
-        environ.declare_memory(memory)?;
-    }
-
-    Ok(())
-}
-
-/// Parses the Tag section of the wasm module.
-pub fn parse_tag_section(
-    tags: TagSectionReader,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    environ.reserve_tags(tags.count())?;
-
-    for entry in tags {
-        let tag = tag(entry?);
-        environ.declare_tag(tag)?;
-    }
-
-    Ok(())
-}
-
-/// Parses the Global section of the wasm module.
-pub fn parse_global_section(
-    globals: GlobalSectionReader,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    environ.reserve_globals(globals.count())?;
-
-    for entry in globals {
-        let wasmparser::Global { ty, init_expr } = entry?;
-        let (initializer, _escaped) = ConstExpr::from_wasmparser(init_expr)?;
-        let ty = environ.convert_global_type(&ty);
-        environ.declare_global(ty, initializer)?;
-    }
-
-    Ok(())
-}
-
-/// Parses the Export section of the wasm module.
-pub fn parse_export_section<'data>(
-    exports: ExportSectionReader<'data>,
-    environ: &mut dyn ModuleEnvironment<'data>,
-) -> WasmResult<()> {
-    environ.reserve_exports(exports.count())?;
-
-    for entry in exports {
-        let Export {
-            name,
-            ref kind,
-            index,
-        } = entry?;
-
-        // The input has already been validated, so we should be able to
-        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
-        // becomes a concern here.
-        let index = index as usize;
-        match *kind {
-            ExternalKind::Func => environ.declare_func_export(FuncIndex::new(index), name)?,
-            ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), name)?,
-            ExternalKind::Memory => environ.declare_memory_export(MemoryIndex::new(index), name)?,
-            ExternalKind::Tag => environ.declare_tag_export(TagIndex::new(index), name)?,
-            ExternalKind::Global => environ.declare_global_export(GlobalIndex::new(index), name)?,
-        }
-    }
-
-    environ.finish_exports()?;
-    Ok(())
-}
-
-/// Parses the Start section of the wasm module.
-pub fn parse_start_section(index: u32, environ: &mut dyn ModuleEnvironment) -> WasmResult<()> {
-    environ.declare_start_func(FuncIndex::from_u32(index))?;
-    Ok(())
-}
-
-fn read_elems(items: &ElementItems) -> WasmResult<Box<[FuncIndex]>> {
-    let mut elems = Vec::new();
-    match items {
-        ElementItems::Functions(funcs) => {
-            for func in funcs.clone() {
-                elems.push(FuncIndex::from_u32(func?));
-            }
-        }
-        ElementItems::Expressions(_ty, funcs) => {
-            for func in funcs.clone() {
-                let idx = match func?.get_binary_reader().read_operator()? {
-                    Operator::RefNull { .. } => FuncIndex::reserved_value(),
-                    Operator::RefFunc { function_index } => FuncIndex::from_u32(function_index),
-                    s => {
-                        return Err(WasmError::Unsupported(format!(
-                            "unsupported init expr in element section: {:?}",
-                            s
-                        )));
-                    }
-                };
-                elems.push(idx);
-            }
-        }
-    }
-    Ok(elems.into_boxed_slice())
-}
-
-/// Parses the Element section of the wasm module.
-pub fn parse_element_section<'data>(
-    elements: ElementSectionReader<'data>,
-    environ: &mut dyn ModuleEnvironment,
-) -> WasmResult<()> {
-    environ.reserve_table_elements(elements.count())?;
-
-    for (index, entry) in elements.into_iter().enumerate() {
-        let Element {
-            kind,
-            items,
-            range: _,
-        } = entry?;
-        let segments = read_elems(&items)?;
-        match kind {
-            ElementKind::Active {
-                table_index,
-                offset_expr,
-            } => {
-                let mut offset_expr_reader = offset_expr.get_binary_reader();
-                let (base, offset) = match offset_expr_reader.read_operator()? {
-                    Operator::I32Const { value } => (None, value as u32),
-                    Operator::GlobalGet { global_index } => {
-                        (Some(GlobalIndex::from_u32(global_index)), 0)
-                    }
-                    ref s => {
-                        return Err(wasm_unsupported!(
-                            "unsupported init expr in element section: {:?}",
-                            s
-                        ));
-                    }
-                };
-                environ.declare_table_elements(
-                    TableIndex::from_u32(table_index.unwrap_or(0)),
-                    base,
-                    offset,
-                    segments,
-                )?
-            }
-            ElementKind::Passive => {
-                let index = ElemIndex::from_u32(index as u32);
-                environ.declare_passive_element(index, segments)?;
-            }
-            ElementKind::Declared => {
-                environ.declare_elements(segments)?;
-            }
-        }
-    }
-    Ok(())
-}
-
-/// Parses the Data section of the wasm module.
-pub fn parse_data_section<'data>(
-    data: DataSectionReader<'data>,
-    environ: &mut dyn ModuleEnvironment<'data>,
-) -> WasmResult<()> {
-    environ.reserve_data_initializers(data.count())?;
-
-    for (index, entry) in data.into_iter().enumerate() {
-        let Data {
-            kind,
-            data,
-            range: _,
-        } = entry?;
-        match kind {
-            DataKind::Active {
-                memory_index,
-                offset_expr,
-            } => {
-                let mut offset_expr_reader = offset_expr.get_binary_reader();
-                let (base, offset) = match offset_expr_reader.read_operator()? {
-                    Operator::I32Const { value } => (None, value as u64),
-                    Operator::I64Const { value } => (None, value as u64),
-                    Operator::GlobalGet { global_index } => {
-                        (Some(GlobalIndex::from_u32(global_index)), 0)
-                    }
-                    ref s => {
-                        return Err(wasm_unsupported!(
-                            "unsupported init expr in data section: {:?}",
-                            s
-                        ))
-                    }
-                };
-                environ.declare_data_initialization(
-                    MemoryIndex::from_u32(memory_index),
-                    base,
-                    offset,
-                    data,
-                )?;
-            }
-            DataKind::Passive => {
-                let index = DataIndex::from_u32(index as u32);
-                environ.declare_passive_data(index, data)?;
-            }
-        }
-    }
-
-    Ok(())
-}

data/ext/cargo-vendor/deterministic-wasi-ctx-0.1.22/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"157b33a158fdc686da92defc1a1310ac0a2ae250cd74d9319e01b474b62f6268","README.md":"42cbd7351f25fd5d7d4134f9e8f669d9353ef53b82b186d6363b2f702a3559f1","src/clocks.rs":"90f061cb55354552a40c437525aabe20b2c2d39b3a6bb87fbf76a11be67b750e","src/lib.rs":"7c57a068c9f34d8d5a0ed6f4e4b5f31ab70af97bfe2193a326a7251c6dd4c281","src/noop_scheduler.rs":"4919984f5f20cfdf123cbeead22f74219521dac2af5968f3ea494c0bd1f11035","tests/clocks.rs":"e15d13d3e1040640922f7a18870581f4449c76af90e40873076f47653542e5b2","tests/common/mod.rs":"5f3d829e8f4eeb7f014f5db5699e74c283a3aff2e49fc002594498d1ad0c720e","tests/random.rs":"3ba63e4ba945826d67799e3650b542fbf1be128530a7ea76904d86fba448b978","tests/scheduler.rs":"f337576ba8f7886fe3974c53eaabdebf3f6ba79aa4c0e42bed5a3e7dc30d4e27"},"package":"ddd21e1781b6a509a4f6a5a8b6a638cd111d185730a531722d1540e49366e5c0"}

data/ext/cargo-vendor/deterministic-wasi-ctx-0.1.22/Cargo.toml

@@ -1,48 +0,0 @@
-# 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 = "deterministic-wasi-ctx"
-version = "0.1.22"
-description = "A wasi-common WasiCtx implementation that is fully deterministic"
-readme = "README.md"
-keywords = ["wasi"]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/Shopify/deterministic-wasi-ctx"
-
-[dependencies.anyhow]
-version = "1.0.56"
-
-[dependencies.async-trait]
-version = "0.1.53"
-
-[dependencies.cap-primitives]
-version = "3.0.0"
-
-[dependencies.rand_core]
-version = "0.6.3"
-
-[dependencies.rand_pcg]
-version = "0.3.1"
-
-[dependencies.wasi-common]
-version = ">= 20.0.0, < 23.0.0"
-
-[dev-dependencies.more-asserts]
-version = "0.3.1"
-
-[dev-dependencies.wasmtime]
-version = "22.0.0"
-
-[dev-dependencies.wasmtime-wasi]
-version = "22.0.0"

data/ext/cargo-vendor/memoffset-0.9.0/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"9039cd9c621a44a65a2fe19c2e883a7b06c6801c64bb9d2255c94adc2051880f","LICENSE":"3234ac55816264ee7b6c7ee27efd61cf0a1fe775806870e3d9b4c41ea73c5cb1","README.md":"a673f0b4b5ac46034590a670572bd1a87837fdedb5170dabbea08d392e6cfa4b","build.rs":"df34c830dbb08eba3474304eed481bc2c8a29e897bc50f46d37b5dbb6e443a2b","src/lib.rs":"a91af41fef48edc5295a99cf90b14273e04db201ed65d88dea101496112c8cd5","src/offset_of.rs":"501f3eb9ec2ada6bd9cd18c73eafdd8ac75bfbfe7e7b543428d9bb97e1cbc478","src/raw_field.rs":"ef54087d5f507c2b639a4f61f2881eb1e41a46e22191ffd0e23b2fe9e3f17c25","src/span_of.rs":"b900faef2b852b52c37c55a172c05c9144bfff7d84dbc06e943fb0453d68adfc"},"package":"5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"}

data/ext/cargo-vendor/memoffset-0.9.0/Cargo.toml

@@ -1,37 +0,0 @@
-# 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]
-name = "memoffset"
-version = "0.9.0"
-authors = ["Gilad Naaman <gilad.naaman@gmail.com>"]
-description = "offset_of functionality for Rust structs."
-readme = "README.md"
-keywords = [
-    "mem",
-    "offset",
-    "offset_of",
-    "offsetof",
-]
-categories = ["no-std"]
-license = "MIT"
-repository = "https://github.com/Gilnaa/memoffset"
-
-[dev-dependencies.doc-comment]
-version = "0.3"
-
-[build-dependencies.autocfg]
-version = "1"
-
-[features]
-default = []
-unstable_const = []
-unstable_offset_of = []

data/ext/cargo-vendor/memoffset-0.9.0/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2017 Gilad Naaman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/ext/cargo-vendor/memoffset-0.9.0/README.md

@@ -1,85 +0,0 @@
-# memoffset #
-
-[![](https://img.shields.io/crates/v/memoffset.svg)](https://crates.io/crates/memoffset)
-
-C-Like `offset_of` functionality for Rust structs.
-
-Introduces the following macros:
- * `offset_of!` for obtaining the offset of a member of a struct.
- * `offset_of_tuple!` for obtaining the offset of a member of a tuple. (Requires Rust 1.20+)
- * `offset_of_union!` for obtaining the offset of a member of a union.
- * `span_of!` for obtaining the range that a field, or fields, span.
-
-`memoffset` works under `no_std` environments.
-
-## Usage ##
-Add the following dependency to your `Cargo.toml`:
-
-```toml
-[dependencies]
-memoffset = "0.8"
-```
-
-These versions will compile fine with rustc versions greater or equal to 1.19.
-
-## Examples ##
-```rust
-use memoffset::{offset_of, span_of};
-
-#[repr(C, packed)]
-struct Foo {
-    a: u32,
-    b: u32,
-    c: [u8; 5],
-    d: u32,
-}
-
-fn main() {
-    assert_eq!(offset_of!(Foo, b), 4);
-    assert_eq!(offset_of!(Foo, d), 4+4+5);
-
-    assert_eq!(span_of!(Foo, a),        0..4);
-    assert_eq!(span_of!(Foo, a ..  c),  0..8);
-    assert_eq!(span_of!(Foo, a ..= c),  0..13);
-    assert_eq!(span_of!(Foo, ..= d),    0..17);
-    assert_eq!(span_of!(Foo, b ..),     4..17);
-}
-```
-
-## Usage in constants ##
-`memoffset` has support for compile-time `offset_of!` on rust>=1.65, or on older nightly compilers.
-
-### Usage on stable Rust ###
-Constant evaluation is automatically enabled and avilable on stable compilers starting with rustc 1.65.
-
-This is an incomplete implementation with one caveat:
-Due to dependence on [`#![feature(const_refs_to_cell)]`](https://github.com/rust-lang/rust/issues/80384), you cannot get the offset of a `Cell` field in a const-context.
-
-This means that if need to get the offset of a cell, you'll have to remain on nightly for now.
-
-### Usage on recent nightlies ###
-
-If you're using a new-enough nightly and you require the ability to get the offset of a `Cell`,
-you'll have to enable the `unstable_const` cargo feature, as well as enabling `const_refs_to_cell` in your crate root.
-
-Do note that `unstable_const` is an unstable feature that is set to be removed in a future version of `memoffset`.
-
-Cargo.toml:
-```toml
-[dependencies.memoffset]
-version = "0.8"
-features = ["unstable_const"]
-```
-
-Your crate root: (`lib.rs`/`main.rs`)
-```rust,ignore
-#![feature(const_refs_to_cell)]
-```
-
-### Usage on older nightlies ###
-In order to use it on an older nightly compiler, you must enable the `unstable_const` crate feature and several compiler features.
-
-Your crate root: (`lib.rs`/`main.rs`)
-```rust,ignore
-#![feature(const_ptr_offset_from, const_refs_to_cell)]
-```

data/ext/cargo-vendor/memoffset-0.9.0/build.rs

@@ -1,25 +0,0 @@
-extern crate autocfg;
-
-fn main() {
-    let ac = autocfg::new();
-
-    // Check for a minimum version for a few features
-    if ac.probe_rustc_version(1, 20) {
-        println!("cargo:rustc-cfg=tuple_ty");
-    }
-    if ac.probe_rustc_version(1, 31) {
-        println!("cargo:rustc-cfg=allow_clippy");
-    }
-    if ac.probe_rustc_version(1, 36) {
-        println!("cargo:rustc-cfg=maybe_uninit");
-    }
-    if ac.probe_rustc_version(1, 40) {
-        println!("cargo:rustc-cfg=doctests");
-    }
-    if ac.probe_rustc_version(1, 51) {
-        println!("cargo:rustc-cfg=raw_ref_macros");
-    }
-    if ac.probe_rustc_version(1, 65) {
-        println!("cargo:rustc-cfg=stable_const");
-    }
-}