Trait wasm_smith::Config

pub trait Config: 'static + Debug {
    // Provided 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 export_everything(&self) -> bool { ... }
    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_table_elements(&self) -> u32 { ... }
    fn table_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 tail_call_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 { ... }
    fn threads_enabled(&self) -> bool { ... }
    fn disallow_traps(&self) -> bool { ... }
}

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

fn min_types(&self) -> usize

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

fn max_types(&self) -> usize

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

fn min_imports(&self) -> usize

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

Note that if the sum of the maximum function¹, 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). ↩

fn max_imports(&self) -> usize

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

fn min_tags(&self) -> usize

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

fn max_tags(&self) -> usize

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

fn available_imports(&self) -> Option<Cow<'_, [u8]>>

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)))
    )
"#))

fn min_funcs(&self) -> usize

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

fn max_funcs(&self) -> usize

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

fn min_globals(&self) -> usize

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

fn max_globals(&self) -> usize

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

fn min_exports(&self) -> usize

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

fn max_exports(&self) -> usize

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

fn export_everything(&self) -> bool

Export all WebAssembly objects in the module. This overrides Config::min_exports and Config::max_exports. Defaults to false.

fn min_element_segments(&self) -> usize

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

fn max_element_segments(&self) -> usize

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

fn min_elements(&self) -> usize

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

fn max_elements(&self) -> usize

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

fn min_data_segments(&self) -> usize

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

fn max_data_segments(&self) -> usize

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

fn max_instructions(&self) -> usize

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.

fn min_memories(&self) -> u32

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

fn max_memories(&self) -> usize

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.

fn min_tables(&self) -> u32

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

fn max_tables(&self) -> usize

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.

fn max_memory_pages(&self, is_64: bool) -> u64

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.

fn memory_max_size_required(&self) -> bool

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

fn max_table_elements(&self) -> u32

The maximum, elements, of any table’s initial or maximum size.

Defaults to 1 million.

fn table_max_size_required(&self) -> bool

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

fn max_instances(&self) -> usize

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

Note that this is irrelevant unless module linking is enabled.

fn max_modules(&self) -> usize

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.

fn max_components(&self) -> usize

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.

fn max_values(&self) -> usize

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.

fn memory_offset_choices(&self) -> (u32, u32, u32)

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).

fn min_uleb_size(&self) -> u8

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.

fn bulk_memory_enabled(&self) -> bool

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

Defaults to false.

fn reference_types_enabled(&self) -> bool

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

Defaults to false.

fn tail_call_enabled(&self) -> bool

Determines whether the tail calls proposal is enabled for generating instructions.

Defaults to false.

fn simd_enabled(&self) -> bool

Determines whether the SIMD proposal is enabled for generating instructions.

Defaults to false.

fn relaxed_simd_enabled(&self) -> bool

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

Defaults to false.

fn exceptions_enabled(&self) -> bool

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

Defaults to false.

fn multi_value_enabled(&self) -> bool

Determines whether the multi-value results are enabled.

Defaults to true.

fn saturating_float_to_int_enabled(&self) -> bool

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

Defaults to true.

fn sign_extension_ops_enabled(&self) -> bool

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

Defaults to true.

fn allow_start_export(&self) -> bool

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

fn max_aliases(&self) -> usize

Returns the maximal size of the alias section.

fn max_nesting_depth(&self) -> usize

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

fn max_type_size(&self) -> u32

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.

fn memory64_enabled(&self) -> bool

Returns whether 64-bit memories are allowed.

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

fn canonicalize_nans(&self) -> bool

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.

fn allowed_instructions(&self) -> InstructionKinds

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.

fn generate_custom_sections(&self) -> bool

Returns whether we should generate custom sections or not.

This is false by default.

fn threads_enabled(&self) -> bool

Determines whether the threads proposal is enabled.

The threads proposal involves shared linear memory, new atomic instructions, and new wait and notify instructions.

Defaults to false.

fn disallow_traps(&self) -> bool

Returns whether we should avoid generating code that will possibly trap.

For some trapping instructions, this will emit extra instructions to ensure they don’t trap, while some instructions will simply be excluded. In cases where we would run into a trap, we instead choose some arbitrary non-trapping behavior. For example, if we detect that a Load instruction would attempt to access out-of-bounds memory, we instead pretend the load succeeded and push 0 onto the stack.

One type of trap that we can’t currently avoid is StackOverflow. Even when disallow_traps is set to true, wasm-smith will eventually generate a program that infinitely recurses, causing the call stack to be exhausted.

Defaults to false.

Implementors

impl Config for DefaultConfig

impl Config for SwarmConfig