Struct Limits 

#[non_exhaustive]
pub struct Limits {
    pub max_bytes: usize,
    pub max_strings: usize,
    pub max_types: usize,
    pub max_consts: usize,
    pub max_const_depth: u32,
    pub max_functions: usize,
    pub max_insts: usize,
    pub max_total_insts: usize,
    pub max_items: usize,
}

The budgets the decoder enforces on untrusted input.

The defaults admit any realistic module (hundreds of megabytes of code) while bounding the work and memory a hostile file can demand. Lower them for a sandbox; there is no “unlimited” mode, because the format itself caps registers, name refs, type refs, and captures at 65,536 per function. Independently of these numbers, no list is allocated before the input is known to be long enough to hold it.

Examples

use bytecode_lang::{decode_with, encode, DecodeErrorKind, Limit, Limits, ModuleBuilder};

let mut m = ModuleBuilder::new();
m.string("a");
m.string("b");
let bytes = encode(&m.finish().unwrap());

let mut limits = Limits::default();
limits.max_strings = 1;
let err = decode_with(&bytes, &limits).unwrap_err();
assert_eq!(err.kind(), &DecodeErrorKind::LimitExceeded(Limit::Strings));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

max_bytes: usize

Maximum input size in bytes. Default 256 MiB.

max_strings: usize

Maximum string-table entries. Default 4,194,304.

max_types: usize

Maximum type-table entries. Default 1,048,576.

max_consts: usize

Maximum constant-pool entries. Default 4,194,304.

max_const_depth: u32

Maximum nesting depth of aggregate constants (a scalar is depth 1). Default 64.

max_functions: usize

Maximum functions. Default 1,048,576.

max_insts: usize

Maximum instructions in one function. Default 16,777,216.

max_total_insts: usize

Maximum instructions in the whole module. Default 33,554,432.

max_items: usize

Maximum length of every other list: imports, globals, exports, parameters, methods, constant elements, byte-string constants (in bytes), jump-table entries, handlers, line rows, locals. Default 16,777,216.

Trait Implementations

impl Clone for Limits

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Limits

impl Debug for Limits

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Limits

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Limits

impl Hash for Limits

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Limits

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Limits