Struct Code

pub struct Code { /* private fields */ }

Contains instrumented binary code of a program and initial memory size from memory import.

Implementations

impl Code

pub fn try_new<R, GetRulesFn>( original_code: Vec<u8>, version: u32, get_gas_rules: GetRulesFn, stack_height: Option<u32>, data_segments_amount_limit: Option<u32>, table_number_limit: Option<u32>, ) -> Result<Self, CodeError>

where R: Rules, GetRulesFn: FnMut(&Module) -> R,

Create the code by checking and instrumenting original_code. Main logic of instrumentation can be represented by this example: Let’s take a code:

(module
   (import "env" "memory" (memory 1))
   (export "init" (func $init))
   (func $f1
      <-- f1 code -->
   )
   (func $f2
      if (i32.eqz (i32.const 0))
         <-- some code -->
      else
         <-- some code -->
      end
   )
   (func $f3
      <-- f3 code -->
   )
   (func $init
      call $f1
      call $f2
      call $f3
      <-- some code -->
   )
)

After instrumentation code will be like:

(module
  (import "env" "memory" (memory 1))
  (export "init" (func $init_export))
  (func $gas_charge
     <-- gas charge impl --> ;; see utils/wasm-instrument/src/lib.rs
  )
  (func $f1
     i32.const 123
     call $gas_charge
     <-- f1 code -->
  )
  (func $f2
     i32.const 123
     call $gas_charge
     if (i32.eqz (i32.const 0))
        i32.const 1
        call $gas_charge
        <-- some code -->
     else
        i32.const 2
        call $gas_charge
        <-- some code -->
     end
  )
  (func $init
     i32.const 123
     call $gas_charge
     ;; stack limit check impl see in wasm_instrument::inject_stack_limiter
     <-- stack limit check and increase -->
     call $f1
     <-- stack limit decrease -->
     <-- stack limit check and increase -->
     call $f2
     <-- stack limit decrease -->
     <-- some code -->
  )
  (func $init_export
     i32.const 123
     call $gas_charge
     <-- stack limit check and increase -->
     call $init
     <-- stack limit decrease -->
  )
)

pub fn try_new_mock_const_or_no_rules( original_code: Vec<u8>, const_rules: bool, config: TryNewCodeConfig, ) -> Result<Self, CodeError>

Create new code for mock goals with const or no instrumentation rules.

pub fn try_new_mock_with_rules<R, GetRulesFn>( original_code: Vec<u8>, get_gas_rules: GetRulesFn, config: TryNewCodeConfig, ) -> Result<Self, CodeError>

where R: Rules, GetRulesFn: FnMut(&Module) -> R,

Create new code for mock goals with custom instrumentation rules.

pub fn original_code(&self) -> &[u8]

Returns the original code.

pub fn code(&self) -> &[u8]

Returns reference to the instrumented binary code.

pub fn exports(&self) -> &BTreeSet<DispatchKind>

Returns wasm module exports.

pub fn instruction_weights_version(&self) -> u32

Returns instruction weights version.

pub fn static_pages(&self) -> WasmPagesAmount

Returns initial memory size from memory import.

pub fn into_parts(self) -> (InstrumentedCode, Vec<u8>)

Consumes this instance and returns the instrumented and raw binary codes.

Trait Implementations

impl Clone for Code

fn clone(&self) -> Code

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Code

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

Formats the value using the given formatter.

impl From<Code> for InstrumentedCode

fn from(code: Code) -> Self

Converts to this type from the input type.

impl PartialEq for Code

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Code

impl StructuralPartialEq for Code