Trait wasm_smith::Config

source · [−]
pub trait Config: 'static + Debug {

Show 48 methods    fn min_types(&self) -> usize { ... }
    fn max_types(&self) -> usize { ... }
    fn min_imports(&self) -> usize { ... }
    fn max_imports(&self) -> usize { ... }
    fn min_tags(&self) -> usize { ... }
    fn max_tags(&self) -> usize { ... }
    fn available_imports(&self) -> Option<Cow<'_, [u8]>> { ... }
    fn min_funcs(&self) -> usize { ... }
    fn max_funcs(&self) -> usize { ... }
    fn min_globals(&self) -> usize { ... }
    fn max_globals(&self) -> usize { ... }
    fn min_exports(&self) -> usize { ... }
    fn max_exports(&self) -> usize { ... }
    fn min_element_segments(&self) -> usize { ... }
    fn max_element_segments(&self) -> usize { ... }
    fn min_elements(&self) -> usize { ... }
    fn max_elements(&self) -> usize { ... }
    fn min_data_segments(&self) -> usize { ... }
    fn max_data_segments(&self) -> usize { ... }
    fn max_instructions(&self) -> usize { ... }
    fn min_memories(&self) -> u32 { ... }
    fn max_memories(&self) -> usize { ... }
    fn min_tables(&self) -> u32 { ... }
    fn max_tables(&self) -> usize { ... }
    fn max_memory_pages(&self, is_64: bool) -> u64 { ... }
    fn memory_max_size_required(&self) -> bool { ... }
    fn max_instances(&self) -> usize { ... }
    fn max_modules(&self) -> usize { ... }
    fn max_components(&self) -> usize { ... }
    fn max_values(&self) -> usize { ... }
    fn memory_offset_choices(&self) -> (u32, u32, u32) { ... }
    fn min_uleb_size(&self) -> u8 { ... }
    fn bulk_memory_enabled(&self) -> bool { ... }
    fn reference_types_enabled(&self) -> bool { ... }
    fn simd_enabled(&self) -> bool { ... }
    fn relaxed_simd_enabled(&self) -> bool { ... }
    fn exceptions_enabled(&self) -> bool { ... }
    fn multi_value_enabled(&self) -> bool { ... }
    fn saturating_float_to_int_enabled(&self) -> bool { ... }
    fn sign_extension_ops_enabled(&self) -> bool { ... }
    fn allow_start_export(&self) -> bool { ... }
    fn max_aliases(&self) -> usize { ... }
    fn max_nesting_depth(&self) -> usize { ... }
    fn max_type_size(&self) -> u32 { ... }
    fn memory64_enabled(&self) -> bool { ... }
    fn canonicalize_nans(&self) -> bool { ... }
    fn allowed_instructions(&self) -> InstructionKinds { ... }
    fn generate_custom_sections(&self) -> bool { ... }

}
Expand description

Configuration for a generated module.

Don’t care to configure your generated modules? Just use Module, which internally uses DefaultConfig.

If you want to configure generated modules, then define a MyConfig type, implement this trait for it, and use ConfiguredModule<MyConfig> instead of Module.

Every trait method has a provided default implementation, so that you only need to override the methods for things you want to change away from the default.

Provided Methods

The minimum number of types to generate. Defaults to 0.

The maximum number of types to generate. Defaults to 100.

The minimum number of imports to generate. Defaults to 0.

Note that if the sum of the maximum function1, table, global and memory counts is less than the minimum number of imports, then it will not be possible to satisfy all constraints (because imports count against the limits for those element kinds). In that case, we strictly follow the max-constraints, and can fail to satisfy this minimum number.

  1. the maximum number of functions is also limited by the number of function types arbitrarily chosen; strictly speaking, then, the maximum number of imports that can be created due to max-constraints is sum(min(num_func_types, max_funcs), max_tables, max_globals, max_memories). ↩

The maximum number of imports to generate. Defaults to 100.

The minimum number of tags to generate. Defaults to 0.

The maximum number of tags to generate. Defaults to 100.

The imports that may be used when generating the module.

Defaults to None which means that any arbitrary import can be generated.

To only allow specific imports, override this method to return a WebAssembly module which describes the imports allowed.

Note that Self::min_imports is ignored when available_imports are enabled.

Panics

The returned value must be a valid binary encoding of a WebAssembly module. wasm-smith will panic if the module cannot be parsed.

Example

An implementation of this method could use the wat crate to provide a human-readable and maintainable description:

Some(wat::parse_str(r#"
    (module
        (import "env" "ping" (func (param i32)))
        (import "env" "pong" (func (result i32)))
        (import "env" "memory" (memory 1))
        (import "env" "table" (table 1))
        (import "env" "tag" (tag (param i32)))
    )
"#))

The minimum number of functions to generate. Defaults to 0. This includes imported functions.

The maximum number of functions to generate. Defaults to 100. This includes imported functions.

The minimum number of globals to generate. Defaults to 0. This includes imported globals.

The maximum number of globals to generate. Defaults to 100. This includes imported globals.

The minimum number of exports to generate. Defaults to 0.

The maximum number of exports to generate. Defaults to 100.

The minimum number of element segments to generate. Defaults to 0.

The maximum number of element segments to generate. Defaults to 100.

The minimum number of elements within a segment to generate. Defaults to 0.

The maximum number of elements within a segment to generate. Defaults to 100.

The minimum number of data segments to generate. Defaults to 0.

The maximum number of data segments to generate. Defaults to 100.

The maximum number of instructions to generate in a function body. Defaults to 100.

Note that some additional ends, elses, and unreachables may be appended to the function body to finish block scopes.

The minimum number of memories to use. Defaults to 0. This includes imported memories.

The maximum number of memories to use. Defaults to 1. This includes imported memories.

Note that more than one memory is in the realm of the multi-memory wasm proposal.

The minimum number of tables to use. Defaults to 0. This includes imported tables.

The maximum number of tables to use. Defaults to 1. This includes imported tables.

Note that more than one table is in the realm of the reference types proposal.

The maximum, in 64k Wasm pages, of any memory’s initial or maximum size.

Defaults to 2^16 = 65536 for 32-bit Wasm and 2^48 for 64-bit wasm.

Whether every Wasm memory must have a maximum size specified. Defaults to false.

The maximum number of instances to use. Defaults to 10. This includes imported instances.

Note that this is irrelevant unless module linking is enabled.

The maximum number of modules to use. Defaults to 10. This includes imported modules.

Note that this is irrelevant unless component model support is enabled.

The maximum number of components to use. Defaults to 10. This includes imported components.

Note that this is irrelevant unless component model support is enabled.

The maximum number of values to use. Defaults to 10. This includes imported values.

Note that this is irrelevant unless value model support is enabled.

Control the probability of generating memory offsets that are in bounds vs. potentially out of bounds.

Return a tuple (a, b, c) where

  • a / (a+b+c) is the probability of generating a memory offset within 0..memory.min_size, i.e. an offset that is definitely in bounds of a non-empty memory. (Note that if a memory is zero-sized, however, no offset will ever be in bounds.)

  • b / (a+b+c) is the probability of generating a memory offset within memory.min_size..memory.max_size, i.e. an offset that is possibly in bounds if the memory has been grown.

  • c / (a+b+c) is the probability of generating a memory offset within the range memory.max_size.., i.e. an offset that is definitely out of bounds.

At least one of a, b, and c must be non-zero.

If you want to always generate memory offsets that are definitely in bounds of a non-zero-sized memory, for example, you could return (1, 0, 0).

By default, returns (75, 24, 1).

The minimum size, in bytes, of all leb-encoded integers. Defaults to 1.

This is useful for ensuring that all leb-encoded integers are decoded as such rather than as simply one byte. This will forcibly extend leb integers with an over-long encoding in some locations if the size would otherwise be smaller than number returned here.

Determines whether the bulk memory proposal is enabled for generating instructions.

Defaults to false.

Determines whether the reference types proposal is enabled for generating instructions.

Defaults to false.

Determines whether the SIMD proposal is enabled for generating instructions.

Defaults to false.

Determines whether the Relaxed SIMD proposal is enabled for generating instructions.

Defaults to false.

Determines whether the exception-handling proposal is enabled for generating instructions.

Defaults to false.

Determines whether the multi-value results are enabled.

Defaults to true.

Determines whether the nontrapping-float-to-int-conversions propsal is enabled.

Defaults to true.

Determines whether the sign-extension-ops propsal is enabled.

Defaults to true.

Determines whether a start export may be included. Defaults to true.

Returns the maximal size of the alias section.

Returns the maximal nesting depth of modules with the module linking proposal.

Returns the maximal effective size of any type generated by wasm-smith.

Note that this number is roughly in units of “how many types would be needed to represent the recursive type”. A function with 8 parameters and 2 results would take 11 types (one for the type, 10 for params/results). A module type with 2 imports and 3 exports would take 6 (module + imports + exports) plus the size of each import/export type. This is a somewhat rough measurement that is not intended to be very precise.

Returns whether 64-bit memories are allowed.

Note that this is the gate for the memory64 proposal to WebAssembly.

Returns whether NaN values are canonicalized after all f32/f64 operation.

This can be useful when a generated wasm module is executed in multiple runtimes which may produce different NaN values. This ensures that the generated module will always use the same NaN representation for all instructions which have visible side effects, for example writing floats to memory or float-to-int bitcast instructions.

Returns the kinds of instructions allowed in the generated wasm programs.

The categories of instructions match the categories used by the WebAssembly specification; e.g., numeric, vector, control, memory, etc. Note that modifying this setting is separate from the proposal flags; that is, if simd_enabled() == true but allowed_instruction() does not include vector instructions, the generated programs will not include these instructions but could contain vector types.

Returns whether we should generate custom sections or not.

This is false by default.

Implementors