Update wasmparser requirement from 0.205 to 0.206 (#103)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.editorconfig

@@ -6,6 +6,22 @@ tab_width=4
 end_of_line=lf
 charset=utf-8
 trim_trailing_whitespace=true
-max_line_length=120
+max_line_length=100
 insert_final_newline=true
 
+[*.md]
+max_line_length=80
+indent_style=space
+indent_size=2
+
+[*.yml]
+indent_style=space
+indent_size=2
+tab_width=8
+end_of_line=lf
+
+[*.sh]
+indent_style=space
+indent_size=2
+tab_width=8
+end_of_line=lf

.github/CODEOWNERS

@@ -0,0 +1,4 @@
+# For details about syntax, see:
+# https://help.github.com/en/articles/about-code-owners
+
+* @athei @pepyakin

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: cargo
+    directory: "/"
+    labels: []
+    schedule:
+      interval: "daily"
+  - package-ecosystem: github-actions
+    directory: '/'
+    schedule:
+      interval: daily

.github/workflows/check.yml

@@ -0,0 +1,112 @@
+name: Check
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  rustfmt:
+    runs-on: "ubuntu_20_64_core"
+    steps:
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          components: rustfmt
+
+      - uses: actions/checkout@v4
+
+      - name: Fmt
+        uses: actions-rs/cargo@v1
+        with:
+          toolchain: nightly
+          command: fmt
+          args: --all -- --check
+
+  clippy:
+    runs-on: "ubuntu_20_64_core"
+    steps:
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          components: clippy
+          default: true
+
+      - uses: actions/checkout@v4
+
+      - name: Clippy
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-targets --all-features -- -D warnings
+
+  build:
+    runs-on: "ubuntu_20_64_core"
+    steps:
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          target: wasm32-unknown-unknown
+          toolchain: stable
+          default: true
+
+      - uses: actions/checkout@v4
+
+      - name: Cargo build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+
+      - name: Cargo build (std)
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --all-features
+
+      - name: Cargo build (no_std)
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --no-default-features
+
+      - name: Cargo build (wasm)
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --no-default-features --target wasm32-unknown-unknown
+
+  test:
+    strategy:
+      matrix:
+        os: ["ubuntu_20_64_core", "macos-latest", "windows-latest"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          default: true
+
+      - name: Set git to use LF
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+
+      - uses: actions/checkout@v4
+
+      - name: Cargo test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features
+

.gitignore

@@ -3,3 +3,5 @@ target
 .cargo
 .DS_Store
 .idea
+.vscode
+*~

.travis.yml

@@ -1,9 +0,0 @@
-language: rust
-rust:
-  - nightly
-  - stable
-
-script:
-  - cargo build --all --release --verbose
-  - cargo test --all --verbose
-  - if [ "$TRAVIS_RUST_VERSION" == "nightly" ]; then cargo build --no-default-features; fi

BENCHMARKS.md

@@ -0,0 +1,91 @@
+# Benchmarks
+
+## Table of Contents
+
+- [Benchmark Results](#benchmark-results)
+    - [coremark, instrumented](#coremark,-instrumented)
+    - [recursive_ok, instrumented](#recursive_ok,-instrumented)
+    - [fibonacci_recursive, instrumented](#fibonacci_recursive,-instrumented)
+    - [factorial_recursive, instrumented](#factorial_recursive,-instrumented)
+    - [count_until, instrumented](#count_until,-instrumented)
+    - [memory_vec_add, instrumented](#memory_vec_add,-instrumented)
+    - [wasm_kernel::tiny_keccak, instrumented](#wasm_kernel::tiny_keccak,-instrumented)
+    - [global_bump, instrumented](#global_bump,-instrumented)
+
+## Instrumented Modules sizes
+
+| fixture                      |  original size   | gas metered/host fn | gas metered/mut global | size diff |
+|------------------------------|------------------|---------------------|------------------------|-----------|
+| recursive_ok.wat             |             0 kb |         0 kb (137%) |            0 kb (177%) |      +29% |
+| count_until.wat              |             0 kb |         0 kb (125%) |            0 kb (153%) |      +21% |
+| global_bump.wat              |             0 kb |         0 kb (123%) |            0 kb (145%) |      +18% |
+| memory-vec-add.wat           |             0 kb |         0 kb (116%) |            0 kb (134%) |      +15% |
+| factorial.wat                |             0 kb |         0 kb (125%) |            0 kb (145%) |      +15% |
+| fibonacci.wat                |             0 kb |         0 kb (121%) |            0 kb (134%) |      +10% |
+| contract_terminate.wasm      |             1 kb |         1 kb (110%) |            1 kb (112%) |       +2% |
+| coremark_minimal.wasm        |             7 kb |         8 kb (114%) |            8 kb (115%) |       +0% |
+| trait_erc20.wasm             |            10 kb |        11 kb (108%) |           11 kb (108%) |       +0% |
+| rand_extension.wasm          |             4 kb |         5 kb (109%) |            5 kb (109%) |       +0% |
+| multisig.wasm                |            27 kb |        30 kb (110%) |           30 kb (110%) |       +0% |
+| wasm_kernel.wasm             |           779 kb |       787 kb (100%) |          795 kb (101%) |       +0% |
+| many_blocks.wasm             |          1023 kb |      2389 kb (233%) |         2389 kb (233%) |       +0% |
+| contract_transfer.wasm       |             7 kb |         8 kb (113%) |            8 kb (113%) |       +0% |
+| erc1155.wasm                 |            26 kb |        29 kb (111%) |           29 kb (111%) |       +0% |
+| erc20.wasm                   |             9 kb |        10 kb (108%) |           10 kb (109%) |       +0% |
+| dns.wasm                     |            10 kb |        11 kb (108%) |           11 kb (108%) |       +0% |
+| proxy.wasm                   |             3 kb |         4 kb (108%) |            4 kb (109%) |       +0% |
+| erc721.wasm                  |            13 kb |        14 kb (108%) |           14 kb (108%) |       +0% |
+
+## Benchmark Results
+
+### coremark, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `20.81 s` (✅ **1.00x**)                 | `20.20 s` (✅ **1.03x faster**)            |
+
+### recursive_ok, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `367.11 us` (✅ **1.00x**)               | `585.39 us` (❌ *1.59x slower*)            |
+
+### fibonacci_recursive, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `9.15 us` (✅ **1.00x**)                 | `13.56 us` (❌ *1.48x slower*)             |
+
+### factorial_recursive, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `1.50 us` (✅ **1.00x**)                 | `1.98 us` (❌ *1.32x slower*)              |
+
+### count_until, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `5.03 ms` (✅ **1.00x**)                 | `8.13 ms` (❌ *1.62x slower*)              |
+
+### memory_vec_add, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `6.21 ms` (✅ **1.00x**)                 | `8.45 ms` (❌ *1.36x slower*)              |
+
+### wasm_kernel::tiny_keccak, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `925.22 us` (✅ **1.00x**)               | `1.08 ms` (❌ *1.17x slower*)              |
+
+### global_bump, instrumented
+
+|        | `with host_function::Injector`          | `with mutable_global::Injector`           |
+|:-------|:----------------------------------------|:----------------------------------------- |
+|        | `3.79 ms` (✅ **1.00x**)                 | `7.03 ms` (❌ *1.86x slower*)              |
+
+---
+Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
+

CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+The semantic versioning guarantees cover the interface to the substrate runtime which
+includes this pallet as a dependency. This module will also add storage migrations whenever
+changes require it. Stability with regard to offchain tooling is explicitly excluded from
+this guarantee: For example adding a new field to an in-storage data structure will require
+changes to frontends to properly display it. However, those changes will still be regarded
+as a minor version bump.
+
+The interface provided to smart contracts will adhere to semver with one exception: Even
+major version bumps will be backwards compatible with regard to already deployed contracts.
+In other words: Upgrading this pallet will not break pre-existing contracts.
+
+## [Unreleased]
+
+### New
+
+- Add new gas metering method: mutable global + local gas function
+[#34](https://github.com/paritytech/wasm-instrument/pull/34)
+- Account for locals initialization costs
+[#38](https://github.com/paritytech/wasm-instrument/pull/38)
+
+## [v0.3.0]
+
+### Changed
+
+- Use 64bit arithmetic for per-block gas counter
+[#30](https://github.com/paritytech/wasm-instrument/pull/30)
+
+## [v0.2.0] 2022-06-06
+
+### Changed
+
+- Adjust debug information (if already parsed) when injecting gas metering
+[#16](https://github.com/paritytech/wasm-instrument/pull/16)
+
+## [v0.1.1] 2022-01-18
+
+### Fixed
+
+- Stack metering disregarded the activiation frame.
+[#2](https://github.com/paritytech/wasm-instrument/pull/2)
+
+## [v0.1.0] 2022-01-11
+
+### Changed
+
+- Created from [pwasm-utils](https://github.com/paritytech/wasm-utils) by removing unused code and cleaning up docs.

Cargo.toml

@@ -1,27 +1,48 @@
 [package]
-name = "pwasm-utils"
-version = "0.1.5"
-authors = ["Nikolay Volf <nikvolf@gmail.com>", "Sergey Pepyakin <s.pepyakin@gmail.com>"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-description = "Collection of command-line utilities and corresponding Rust api for producing pwasm-compatible executables"
-keywords = ["wasm", "webassembly", "pwasm"]
+name = "wasm-instrument"
+version = "0.4.0"
+edition = "2021"
+rust-version = "1.56.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+license = "MIT OR Apache-2.0"
+description = "Instrument and transform wasm modules."
+keywords = ["wasm", "webassembly", "blockchain", "gas-metering", "parity"]
+categories = ["wasm", "no-std"]
+repository = "https://github.com/paritytech/wasm-instrument"
+include = ["src/**/*", "LICENSE-*", "README.md"]
+
+[[bench]]
+name = "instrumentation"
+harness = false
+path = "benches/instrumentation.rs"
+
+[[bench]]
+name = "execution"
+harness = false
+path = "benches/execution.rs"
+
+[profile.bench]
+lto = "fat"
+codegen-units = 1
 
 [dependencies]
-parity-wasm = { version = "0.30", default-features = false }
-log = { version = "0.4", default-features = false }
-byteorder = { version = "1", default-features = false }
+parity-wasm = { version = "0.45", default-features = false }
 
 [dev-dependencies]
-tempdir = "0.3"
-wabt = "0.2"
-diff = "0.1.11"
+binaryen = "0.12"
+criterion = "0.5"
+diff = "0.1"
+pretty_assertions = "1"
+rand = "0.8"
+wat = "1"
+wasmparser = "0.206"
+wasmprinter = "0.200"
+wasmi = "0.31"
 
 [features]
 default = ["std"]
-std = ["parity-wasm/std", "log/std", "byteorder/std"]
+std = ["parity-wasm/std"]
+sign_ext = ["parity-wasm/sign_ext"]
 
-[workspace]
-members = [
-  "./cli",
-]
+[lib]
+bench = false

LICENSE-MIT

@@ -1,5 +1,3 @@
-Copyright (c) 2017 Nikolay Volf
-
 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

README.md

@@ -1,58 +1,33 @@
-# wasm-utils
+# wasm-instrument
 
-[![Build Status](https://travis-ci.org/paritytech/wasm-utils.svg?branch=master)](https://travis-ci.org/paritytech/wasm-utils)
+A Rust library containing a collection of wasm module instrumentations and transformations
+mainly useful for wasm based block chains and smart contracts.
 
-Collection of WASM utilities used in Parity and WASM contract devepment
+## Provided functionality
 
-## Build tools for cargo
+This is a non exhaustive list of provided functionality. Please check out the [documentation](https://docs.rs/wasm-instrument/latest/wasm_instrument/) for details.
 
-Easiest way to use is to install via `cargo install`:
+### Gas Metering
 
-```
-cargo install pwasm-utils --bin wasm-build
-```
+Add gas metering to your platform by injecting the necessary code directly into the wasm module. This allows having a uniform gas metering implementation across different execution engines (interpreters, JIT compilers).
 
-## Symbols pruning (wasm-prune)
+### Stack Height Limiter
 
-```
-cargo install pwasm-utils
-wasm-prune <input_wasm_binary.wasm> <output_wasm_binary.wasm>
-```
+Neither the wasm standard nor any sufficiently complex execution engine specifies how many items on the wasm stack are supported before the execution aborts or malfunctions. Even the same execution engine on different operating systems or host architectures could support a different number of stack items and be well within its rights.
 
-This will optimize WASM symbols tree to leave only those elements that are used by contract `_call` function entry.
+This is the kind of indeterminism that can lead to consensus failures when used in a blockchain context.
 
-## Gas counter (wasm-gas)
+To address this issue we can inject some code that meters the stack height at runtime and aborts the execution when it reaches a predefined limit. Choosing this limit suffciently small so that it is smaller than what any reasonably parameterized execution engine would support solves the issue: All execution engines would reach the injected limit before hitting any implementation specific limitation.
 
-For development puposes, raw WASM contract can be injected with gas counters (the same way as it done by Parity runtime when running contracts)
+## License
 
-```
-cargo install pwasm-utils
-wasm-gas <input_wasm_binary.wasm> <output_wasm_binary.wasm>
-```
-
-## Externalization (wasm-ext)
-
-Parity WASM runtime provides some library functions that can be commonly found in libc. WASM binary size can be reduced and performance may be improved if these functions are used. This utility scans for invocations of the following functions inside the WASM binary:
-- `_malloc`,
-- `_free`,
-- `_memcpy`,
-- `_memset`,
-- `_memmove`
-
-And then substitutes them with invocations of the imported ones. Should be run before `wasm-opt` for better results.
-
-```
-cargo install pwasm-utils
-wasm-ext <input_wasm_binary.wasm> <output_wasm_binary.wasm>
-```
-
-## API
-
-All executables use corresponding api methods of the root crate and can be combined in other build tools.
-
-# License
-
-`wasm-utils` is primarily distributed under the terms of both the MIT
-license and the Apache License (Version 2.0), at your choice.
+`wasm-instrument` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0), at your choice.
 
 See LICENSE-APACHE, and LICENSE-MIT for details.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in `wasm-instrument` by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.

benches/execution.rs

@@ -0,0 +1,437 @@
+use criterion::{
+	criterion_group, criterion_main, measurement::Measurement, Bencher, BenchmarkGroup, Criterion,
+};
+use std::{
+	fs::read,
+	path::PathBuf,
+	time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use wasm_instrument::{
+	gas_metering::{self, host_function, mutable_global, ConstantCostRules},
+	parity_wasm::{deserialize_buffer, elements::Module, serialize},
+};
+use wasmi::{
+	core::{Pages, TrapCode, F32},
+	Caller, Config, Engine, Instance, Linker, Memory, StackLimits, Store, TypedFunc, Value,
+};
+
+/// Describes a gas metering strategy we want to benchmark.
+///
+/// Most strategies just need a subset of these functions. Hence we added default
+/// implementations for all of them.
+trait MeteringStrategy {
+	/// The wasmi config we should be using for this strategy.
+	fn config() -> Config {
+		Config::default()
+	}
+
+	/// The strategy may or may not want to instrument the module.
+	fn instrument_module(module: Module) -> Module {
+		module
+	}
+
+	/// The strategy might need to define additional host functions.
+	fn define_host_funcs(_linker: &mut Linker<u64>) {}
+
+	/// The strategy might need to do some initialization of the wasm instance.
+	fn init_instance(_module: &mut BenchInstance) {}
+}
+
+/// Don't do any metering at all. This is helpful as a baseline.
+struct NoMetering;
+
+/// Use wasmi's builtin fuel metering.
+struct WasmiMetering;
+
+/// Instrument the module using [`host_function::Injector`].
+struct HostFunctionMetering;
+
+/// Instrument the module using [`mutable_global::Injector`].
+struct MutableGlobalMetering;
+
+impl MeteringStrategy for NoMetering {}
+
+impl MeteringStrategy for WasmiMetering {
+	fn config() -> Config {
+		let mut config = Config::default();
+		config.consume_fuel(true);
+		config
+	}
+
+	fn init_instance(module: &mut BenchInstance) {
+		module.store.add_fuel(u64::MAX).unwrap();
+	}
+}
+
+impl MeteringStrategy for HostFunctionMetering {
+	fn instrument_module(module: Module) -> Module {
+		let backend = host_function::Injector::new("env", "gas");
+		gas_metering::inject(module, backend, &ConstantCostRules::default()).unwrap()
+	}
+
+	fn define_host_funcs(linker: &mut Linker<u64>) {
+		// the instrumentation relies on the existing of this function
+		linker
+			.func_wrap("env", "gas", |mut caller: Caller<'_, u64>, amount_consumed: u64| {
+				let gas_remaining = caller.data_mut();
+				*gas_remaining =
+					gas_remaining.checked_sub(amount_consumed).ok_or(TrapCode::OutOfFuel)?;
+				Ok(())
+			})
+			.unwrap();
+	}
+}
+
+impl MeteringStrategy for MutableGlobalMetering {
+	fn instrument_module(module: Module) -> Module {
+		let backend = mutable_global::Injector::new("gas_left");
+		gas_metering::inject(module, backend, &ConstantCostRules::default()).unwrap()
+	}
+
+	fn init_instance(module: &mut BenchInstance) {
+		// the instrumentation relies on the host to initialize the global with the gas limit
+		// we just init to the maximum so it will never run out
+		module
+			.instance
+			.get_global(&mut module.store, "gas_left")
+			.unwrap()
+			.set(&mut module.store, Value::I64(-1i64)) // the same as u64::MAX
+			.unwrap();
+	}
+}
+
+/// A wasm instance ready to be benchmarked.
+struct BenchInstance {
+	store: Store<u64>,
+	instance: Instance,
+}
+
+impl BenchInstance {
+	/// Create a new instance for the supplied metering strategy.
+	///
+	/// `wasm`: The raw wasm module for the benchmark.
+	/// `define_host_func`: In here the caller can define additional host function.
+	fn new<S, H>(wasm: &[u8], define_host_funcs: &H) -> Self
+	where
+		S: MeteringStrategy,
+		H: Fn(&mut Linker<u64>),
+	{
+		let module = deserialize_buffer(wasm).unwrap();
+		let instrumented_module = S::instrument_module(module);
+		let input = serialize(instrumented_module).unwrap();
+		let mut config = S::config();
+		config.set_stack_limits(StackLimits::new(1024, 1024 * 1024, 64 * 1024).unwrap());
+		let engine = Engine::new(&config);
+		let module = wasmi::Module::new(&engine, &mut &input[..]).unwrap();
+		let mut linker = Linker::new(&engine);
+		S::define_host_funcs(&mut linker);
+		define_host_funcs(&mut linker);
+		// init host state with maximum gas_left (only used by host_function instrumentation)
+		let mut store = Store::new(&engine, u64::MAX);
+		let instance = linker.instantiate(&mut store, &module).unwrap().start(&mut store).unwrap();
+		let mut bench_module = Self { store, instance };
+		S::init_instance(&mut bench_module);
+		bench_module
+	}
+}
+
+/// Runs a benchmark for every strategy.
+///
+/// We require the closures to implement `Fn` as they are executed for every strategy and we
+/// don't want them to change in between.
+///
+/// `group`: The benchmark group within the benchmarks will be executed.
+/// `wasm`: The raw wasm module for the benchmark.
+/// `define_host_func`: In here the caller can define additional host function.
+/// `f`: In here the user should perform the benchmark. Will be executed for every strategy.
+fn for_strategies<M, H, F>(group: &mut BenchmarkGroup<M>, wasm: &[u8], define_host_funcs: H, f: F)
+where
+	M: Measurement,
+	H: Fn(&mut Linker<u64>),
+	F: Fn(&mut Bencher<M>, &mut BenchInstance),
+{
+	let mut module = BenchInstance::new::<NoMetering, _>(wasm, &define_host_funcs);
+	group.bench_function("no_metering", |bench| f(bench, &mut module));
+
+	let mut module = BenchInstance::new::<WasmiMetering, _>(wasm, &define_host_funcs);
+	group.bench_function("wasmi_builtin", |bench| f(bench, &mut module));
+
+	let mut module = BenchInstance::new::<HostFunctionMetering, _>(wasm, &define_host_funcs);
+	group.bench_function("host_function", |bench| f(bench, &mut module));
+
+	let mut module = BenchInstance::new::<MutableGlobalMetering, _>(wasm, &define_host_funcs);
+	group.bench_function("mutable_global", |bench| f(bench, &mut module));
+}
+
+/// Converts the `.wat` encoded `bytes` into `.wasm` encoded bytes.
+fn wat2wasm(bytes: &[u8]) -> Vec<u8> {
+	wat::parse_bytes(bytes).unwrap().into_owned()
+}
+
+fn fixture_dir() -> PathBuf {
+	let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+	path.push("benches");
+	path.push("fixtures");
+	path.push("wasm");
+	path
+}
+
+fn gas_metered_coremark(c: &mut Criterion) {
+	let mut group = c.benchmark_group("coremark");
+	// Benchmark host_function::Injector
+	let wasm_filename = "coremark_minimal.wasm";
+	let bytes = read(fixture_dir().join(wasm_filename)).unwrap();
+	let define_host_funcs = |linker: &mut Linker<u64>| {
+		linker
+			.func_wrap("env", "clock_ms", || {
+				SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
+			})
+			.unwrap();
+	};
+	for_strategies(&mut group, &bytes, define_host_funcs, |bench, module| {
+		bench.iter(|| {
+			let run = module.instance.get_typed_func::<(), F32>(&mut module.store, "run").unwrap();
+			// Call the wasm!
+			run.call(&mut module.store, ()).unwrap();
+		})
+	});
+}
+
+fn gas_metered_recursive_ok(c: &mut Criterion) {
+	let mut group = c.benchmark_group("recursive_ok");
+	const RECURSIVE_DEPTH: i32 = 8000;
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/recursive_ok.wat"));
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let bench_call =
+				module.instance.get_typed_func::<i32, i32>(&module.store, "call").unwrap();
+			bench.iter(|| {
+				let result = bench_call.call(&mut module.store, RECURSIVE_DEPTH).unwrap();
+				assert_eq!(result, 0);
+			})
+		},
+	);
+}
+
+fn gas_metered_fibonacci_recursive(c: &mut Criterion) {
+	let mut group = c.benchmark_group("fibonacci_recursive");
+	const FIBONACCI_REC_N: i64 = 10;
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/fibonacci.wat"));
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let bench_call = module
+				.instance
+				.get_typed_func::<i64, i64>(&module.store, "fib_recursive")
+				.unwrap();
+			bench.iter(|| {
+				bench_call.call(&mut module.store, FIBONACCI_REC_N).unwrap();
+			});
+		},
+	);
+}
+
+fn gas_metered_fac_recursive(c: &mut Criterion) {
+	let mut group = c.benchmark_group("factorial_recursive");
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/factorial.wat"));
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let fac = module
+				.instance
+				.get_typed_func::<i64, i64>(&module.store, "recursive_factorial")
+				.unwrap();
+			bench.iter(|| {
+				let result = fac.call(&mut module.store, 25).unwrap();
+				assert_eq!(result, 7034535277573963776);
+			})
+		},
+	);
+}
+
+fn gas_metered_count_until(c: &mut Criterion) {
+	const COUNT_UNTIL: i32 = 100_000;
+	let mut group = c.benchmark_group("count_until");
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/count_until.wat"));
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let count_until = module
+				.instance
+				.get_typed_func::<i32, i32>(&module.store, "count_until")
+				.unwrap();
+			bench.iter(|| {
+				let result = count_until.call(&mut module.store, COUNT_UNTIL).unwrap();
+				assert_eq!(result, COUNT_UNTIL);
+			})
+		},
+	);
+}
+
+fn gas_metered_vec_add(c: &mut Criterion) {
+	fn test_for<A, B>(
+		b: &mut Bencher,
+		vec_add: TypedFunc<(i32, i32, i32, i32), ()>,
+		mut store: &mut Store<u64>,
+		mem: Memory,
+		len: usize,
+		vec_a: A,
+		vec_b: B,
+	) where
+		A: IntoIterator<Item = i32>,
+		B: IntoIterator<Item = i32>,
+	{
+		use core::mem::size_of;
+
+		let ptr_result = 10;
+		let len_result = len * size_of::<i64>();
+		let ptr_a = ptr_result + len_result;
+		let len_a = len * size_of::<i32>();
+		let ptr_b = ptr_a + len_a;
+
+		// Reset `result` buffer to zeros:
+		mem.data_mut(&mut store)[ptr_result..ptr_result + (len * size_of::<i32>())].fill(0);
+		// Initialize `a` buffer:
+		for (n, a) in vec_a.into_iter().take(len).enumerate() {
+			mem.write(&mut store, ptr_a + (n * size_of::<i32>()), &a.to_le_bytes()).unwrap();
+		}
+		// Initialize `b` buffer:
+		for (n, b) in vec_b.into_iter().take(len).enumerate() {
+			mem.write(&mut store, ptr_b + (n * size_of::<i32>()), &b.to_le_bytes()).unwrap();
+		}
+
+		// Prepare parameters and all Wasm `vec_add`:
+		let params = (ptr_result as i32, ptr_a as i32, ptr_b as i32, len as i32);
+		b.iter(|| {
+			vec_add.call(&mut store, params).unwrap();
+		});
+
+		// Validate the result buffer:
+		for n in 0..len {
+			let mut buffer4 = [0x00; 4];
+			let mut buffer8 = [0x00; 8];
+			let a = {
+				mem.read(&store, ptr_a + (n * size_of::<i32>()), &mut buffer4).unwrap();
+				i32::from_le_bytes(buffer4)
+			};
+			let b = {
+				mem.read(&store, ptr_b + (n * size_of::<i32>()), &mut buffer4).unwrap();
+				i32::from_le_bytes(buffer4)
+			};
+			let actual_result = {
+				mem.read(&store, ptr_result + (n * size_of::<i64>()), &mut buffer8).unwrap();
+				i64::from_le_bytes(buffer8)
+			};
+			let expected_result = (a as i64) + (b as i64);
+			assert_eq!(
+				expected_result, actual_result,
+				"given a = {a} and b = {b}, results diverge at index {n}"
+			);
+		}
+	}
+
+	let mut group = c.benchmark_group("memory_vec_add");
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/memory-vec-add.wat"));
+	const LEN: usize = 100_000;
+
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let vec_add = module
+				.instance
+				.get_typed_func::<(i32, i32, i32, i32), ()>(&module.store, "vec_add")
+				.unwrap();
+			let mem = module.instance.get_memory(&module.store, "mem").unwrap();
+			mem.grow(&mut module.store, Pages::new(25).unwrap()).unwrap();
+			test_for(
+				bench,
+				vec_add,
+				&mut module.store,
+				mem,
+				LEN,
+				(0..LEN).map(|i| (i * i) as i32),
+				(0..LEN).map(|i| (i * 10) as i32),
+			)
+		},
+	);
+}
+
+fn gas_metered_tiny_keccak(c: &mut Criterion) {
+	let mut group = c.benchmark_group("wasm_kernel::tiny_keccak");
+	let wasm_filename = "wasm_kernel.wasm";
+	let wasm_bytes = read(fixture_dir().join(wasm_filename)).unwrap();
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let prepare = module
+				.instance
+				.get_typed_func::<(), i32>(&module.store, "prepare_tiny_keccak")
+				.unwrap();
+			let keccak = module
+				.instance
+				.get_typed_func::<i32, ()>(&module.store, "bench_tiny_keccak")
+				.unwrap();
+			let test_data_ptr = prepare.call(&mut module.store, ()).unwrap();
+			bench.iter(|| {
+				keccak.call(&mut module.store, test_data_ptr).unwrap();
+			})
+		},
+	);
+}
+
+fn gas_metered_global_bump(c: &mut Criterion) {
+	const BUMP_AMOUNT: i32 = 100_000;
+	let mut group = c.benchmark_group("global_bump");
+	let wasm_bytes = wat2wasm(include_bytes!("fixtures/wat/global_bump.wat"));
+	for_strategies(
+		&mut group,
+		&wasm_bytes,
+		|_| {},
+		|bench, module| {
+			let bump = module.instance.get_typed_func::<i32, i32>(&module.store, "bump").unwrap();
+			bench.iter(|| {
+				let result = bump.call(&mut module.store, BUMP_AMOUNT).unwrap();
+				assert_eq!(result, BUMP_AMOUNT);
+			})
+		},
+	);
+}
+
+criterion_group!(
+	name = coremark;
+	config = Criterion::default()
+		.sample_size(10)
+		.measurement_time(Duration::from_millis(275000))
+		.warm_up_time(Duration::from_millis(1000));
+	targets =
+		 gas_metered_coremark,
+);
+criterion_group!(
+	name = wasmi_fixtures;
+	config = Criterion::default()
+		.sample_size(10)
+		.measurement_time(Duration::from_millis(250000))
+	.warm_up_time(Duration::from_millis(1000));
+	targets =
+		gas_metered_recursive_ok,
+		gas_metered_fibonacci_recursive,
+		gas_metered_fac_recursive,
+		gas_metered_count_until,
+		gas_metered_vec_add,
+		gas_metered_tiny_keccak,
+		gas_metered_global_bump,
+);
+criterion_main!(coremark, wasmi_fixtures);

benches/fixtures/wat/count_until.wat

@@ -0,0 +1,25 @@
+;; Exports a function `count_until` that takes an input `n`.
+;; The exported function counts an integer `n` times and then returns `n`.
+(module
+  (func $count_until (export "count_until") (param $limit i32) (result i32)
+    (local $counter i32)
+    (block
+        (loop
+            (br_if
+                1
+                (i32.eq
+                    (local.tee $counter
+                        (i32.add
+                            (local.get $counter)
+                            (i32.const 1)
+                        )
+                    )
+                    (local.get $limit)
+                )
+            )
+            (br 0)
+        )
+    )
+    (return (local.get $counter))
+  )
+)

benches/fixtures/wat/factorial.wat

@@ -0,0 +1,35 @@
+(module
+    ;; Iterative factorial function, does not use recursion.
+    (func (export "iterative_factorial") (param i64) (result i64)
+        (local i64)
+        (local.set 1 (i64.const 1))
+        (block
+            (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+            (loop
+                (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+                (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+                (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+            )
+        )
+        (local.get 1)
+    )
+
+    ;; Recursive trivial factorial function.
+    (func $rec_fac (export "recursive_factorial") (param i64) (result i64)
+        (if (result i64)
+            (i64.eq (local.get 0) (i64.const 0))
+            (then (i64.const 1))
+            (else
+                (i64.mul
+                    (local.get 0)
+                    (call $rec_fac
+                        (i64.sub
+                            (local.get 0)
+                            (i64.const 1)
+                        )
+                    )
+                )
+            )
+        )
+    )
+)

benches/fixtures/wat/fibonacci.wat

@@ -0,0 +1,47 @@
+(module
+    (func $fib_recursive (export "fib_recursive") (param $N i64) (result i64)
+        (if
+            (i64.le_s (local.get $N) (i64.const 1))
+            (then (return (local.get $N)))
+        )
+        (return
+            (i64.add
+                (call $fib_recursive
+                  (i64.sub (local.get $N) (i64.const 1))
+                )
+                (call $fib_recursive
+                  (i64.sub (local.get $N) (i64.const 2))
+                )
+            )
+        )
+    )
+
+    (func $fib_iterative (export "fib_iterative") (param $N i64) (result i64)
+        (local $n1 i64)
+        (local $n2 i64)
+        (local $tmp i64)
+        (local $i i64)
+        ;; return $N for N <= 1
+        (if
+            (i64.le_s (local.get $N) (i64.const 1))
+            (then (return (local.get $N)))
+        )
+        (local.set $n1 (i64.const 1))
+        (local.set $n2 (i64.const 1))
+        (local.set $i (i64.const 2))
+        ;;since we normally return n2, handle n=1 case specially
+        (loop $again
+            (if
+                (i64.lt_s (local.get $i) (local.get $N))
+                (then
+                    (local.set $tmp (i64.add (local.get $n1) (local.get $n2)))
+                    (local.set $n1 (local.get $n2))
+                    (local.set $n2 (local.get $tmp))
+                    (local.set $i (i64.add (local.get $i) (i64.const 1)))
+                    (br $again)
+                )
+            )
+        )
+        (local.get $n2)
+    )
+)

benches/fixtures/wat/global_bump.wat

@@ -0,0 +1,27 @@
+;; Exports a function `bump` that takes an input `n`.
+;; The exported function bumps a global variable `n` times and then returns it.
+(module
+    (global $g (mut i32) (i32.const 0))
+    (func $bump (export "bump") (param $n i32) (result i32)
+        (global.set $g (i32.const 0))
+        (block $break
+            (loop $continue
+                (br_if ;; if $g == $n then break
+                    $break
+                    (i32.eq
+                        (global.get $g)
+                        (local.get $n)
+                    )
+                )
+                (global.set $g ;; $g += 1
+                    (i32.add
+                        (global.get $g)
+                        (i32.const 1)
+                    )
+                )
+                (br $continue)
+            )
+        )
+        (return (global.get $g))
+    )
+)

benches/fixtures/wat/memory-vec-add.wat

@@ -0,0 +1,58 @@
+;; Exports a function `vec_add` that computes the addition of 2 vectors
+;; of length `len` starting at `ptr_a` and `ptr_b` and stores the result
+;; into a buffer of the same length starting at `ptr_result`.
+(module
+    (memory (export "mem") 1)
+    (func (export "vec_add")
+        (param $ptr_result i32)
+        (param $ptr_a i32)
+        (param $ptr_b i32)
+        (param $len i32)
+        (local $n i32)
+        (block $exit
+            (loop $loop
+                (br_if ;; exit loop if $n == $len
+                    $exit
+                    (i32.eq
+                        (local.get $n)
+                        (local.get $len)
+                    )
+                )
+                (i64.store offset=0 ;; ptr_result[n] = ptr_a[n] + ptr_b[n]
+                    (i32.add
+                        (local.get $ptr_result)
+                        (i32.mul
+                            (local.get $n)
+                            (i32.const 8)
+                        )
+                    )
+                    (i64.add
+                        (i64.load32_s offset=0 ;; load ptr_a[n]
+                            (i32.add
+                                (local.get $ptr_a)
+                                (i32.mul
+                                    (local.get $n)
+                                    (i32.const 4)
+                                )
+                            )
+                        )
+                        (i64.load32_s offset=0 ;; load ptr_b[n]
+                            (i32.add
+                                (local.get $ptr_b)
+                                (i32.mul
+                                    (local.get $n)
+                                    (i32.const 4)
+                                )
+                            )
+                        )
+                    )
+                )
+                (local.set $n ;; increment n
+                    (i32.add (local.get $n) (i32.const 1))
+                 )
+                (br $loop) ;; continue loop
+            )
+        )
+        (return)
+    )
+)

benches/fixtures/wat/recursive_ok.wat

@@ -0,0 +1,22 @@
+;; Exports a function `call` that takes an input `n`.
+;; The exported function calls itself `n` times.
+(module
+    (func $call (export "call") (param $n i32) (result i32)
+        (if (result i32)
+            (local.get $n)
+            (then
+                (return
+                    (call $call
+                        (i32.sub
+                            (local.get $n)
+                            (i32.const 1)
+                        )
+                    )
+                )
+            )
+            (else
+                (return (local.get $n))
+            )
+        )
+    )
+)

benches/instrumentation.rs

@@ -0,0 +1,58 @@
+use criterion::{
+	criterion_group, criterion_main, measurement::Measurement, BenchmarkGroup, Criterion,
+	Throughput,
+};
+use std::{
+	fs::{read, read_dir},
+	path::PathBuf,
+};
+use wasm_instrument::{
+	gas_metering::{self, host_function, ConstantCostRules},
+	inject_stack_limiter,
+	parity_wasm::{deserialize_buffer, elements::Module},
+};
+
+fn fixture_dir() -> PathBuf {
+	let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+	path.push("benches");
+	path.push("fixtures");
+	path.push("wasm");
+	path
+}
+
+fn for_fixtures<F, M>(group: &mut BenchmarkGroup<M>, f: F)
+where
+	F: Fn(Module),
+	M: Measurement,
+{
+	for entry in read_dir(fixture_dir()).unwrap() {
+		let entry = entry.unwrap();
+		let bytes = read(entry.path()).unwrap();
+		group.throughput(Throughput::Bytes(bytes.len().try_into().unwrap()));
+		group.bench_with_input(entry.file_name().to_str().unwrap(), &bytes, |bench, input| {
+			bench.iter(|| f(deserialize_buffer(input).unwrap()))
+		});
+	}
+}
+
+fn gas_metering(c: &mut Criterion) {
+	let mut group = c.benchmark_group("Gas Metering");
+	for_fixtures(&mut group, |module| {
+		gas_metering::inject(
+			module,
+			host_function::Injector::new("env", "gas"),
+			&ConstantCostRules::default(),
+		)
+		.unwrap();
+	});
+}
+
+fn stack_height_limiter(c: &mut Criterion) {
+	let mut group = c.benchmark_group("Stack Height Limiter");
+	for_fixtures(&mut group, |module| {
+		inject_stack_limiter(module, 128).unwrap();
+	});
+}
+
+criterion_group!(benches, gas_metering, stack_height_limiter);
+criterion_main!(benches);

cli/Cargo.toml

@@ -1,42 +0,0 @@
-[package]
-name = "pwasm-utils-cli"
-version = "0.1.5"
-authors = ["Nikolay Volf <nikvolf@gmail.com>", "Sergey Pepyakin <s.pepyakin@gmail.com>"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-description = "Collection of command-line utilities and corresponding Rust api for producing pwasm-compatible executables"
-keywords = ["wasm", "webassembly", "pwasm"]
-
-[lib]
-
-[[bin]]
-name = "wasm-prune"
-path = "prune/main.rs"
-
-[[bin]]
-name = "wasm-ext"
-path = "ext/main.rs"
-
-[[bin]]
-name = "wasm-gas"
-path = "gas/main.rs"
-
-[[bin]]
-name = "wasm-build"
-path = "build/main.rs"
-
-[[bin]]
-name = "wasm-stack-height"
-path = "stack_height/main.rs"
-
-[dependencies]
-parity-wasm = "0.30"
-pwasm-utils = { path = ".." }
-glob = "0.2"
-clap = "2.24"
-log = "0.4"
-env_logger = "0.5"
-lazy_static = "1.0"
-
-[dev-dependencies]
-tempdir = "0.3"

cli/build/main.rs

@@ -1,269 +0,0 @@
-//! Experimental build tool for cargo
-
-extern crate glob;
-extern crate pwasm_utils as utils;
-extern crate clap;
-extern crate parity_wasm;
-extern crate pwasm_utils_cli as logger;
-
-mod source;
-
-use std::{fs, io};
-use std::io::Write;
-use std::path::PathBuf;
-
-use clap::{App, Arg};
-use parity_wasm::elements;
-
-use utils::{CREATE_SYMBOL, CALL_SYMBOL, ununderscore_funcs, externalize_mem, shrink_unknown_stack};
-
-#[derive(Debug)]
-pub enum Error {
-	Io(io::Error),
-	FailedToCopy(String),
-	Decoding(elements::Error, String),
-	Encoding(elements::Error),
-	Packing(utils::PackingError),
-	Optimizer,
-}
-
-impl From<io::Error> for Error {
-	fn from(err: io::Error) -> Self {
-		Error::Io(err)
-	}
-}
-
-impl From<utils::OptimizerError> for Error {
-	fn from(_err: utils::OptimizerError) -> Self {
-		Error::Optimizer
-	}
-}
-
-impl From<utils::PackingError> for Error {
-	fn from(err: utils::PackingError) -> Self {
-		Error::Packing(err)
-	}
-}
-
-impl std::fmt::Display for Error {
-	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		use Error::*;
-		match *self {
-			Io(ref io) => write!(f, "Generic i/o error: {}", io),
-			FailedToCopy(ref msg) => write!(f, "{}. Have you tried to run \"cargo build\"?", msg),
-			Decoding(ref err, ref file) => write!(f, "Decoding error ({}). Must be a valid wasm file {}. Pointed wrong file?", err, file),
-			Encoding(ref err) => write!(f, "Encoding error ({}). Almost impossible to happen, no free disk space?", err),
-			Optimizer => write!(f, "Optimization error due to missing export section. Pointed wrong file?"),
-			Packing(ref e) => write!(f, "Packing failed due to module structure error: {}. Sure used correct libraries for building contracts?", e),
-		}
-	}
-}
-
-pub fn wasm_path(input: &source::SourceInput) -> String {
-	let mut path = PathBuf::from(input.target_dir());
-	path.push(format!("{}.wasm", input.final_name()));
-	path.to_string_lossy().to_string()
-}
-
-pub fn process_output(input: &source::SourceInput) -> Result<(), Error> {
-	let mut cargo_path = PathBuf::from(input.target_dir());
-	let wasm_name = input.bin_name().to_string().replace("-", "_");
-	cargo_path.push(
-		match input.target() {
-			source::SourceTarget::Emscripten => source::EMSCRIPTEN_TRIPLET,
-			source::SourceTarget::Unknown => source::UNKNOWN_TRIPLET,
-		}
-	);
-	cargo_path.push("release");
-	cargo_path.push(format!("{}.wasm", wasm_name));
-
-	let mut target_path = PathBuf::from(input.target_dir());
-	target_path.push(format!("{}.wasm", input.final_name()));
-	fs::copy(cargo_path.as_path(), target_path.as_path())
-		.map_err(|io| Error::FailedToCopy(
-			format!("Failed to copy '{}' to '{}': {}", cargo_path.display(), target_path.display(), io)
-		))?;
-
-	Ok(())
-}
-
-fn has_ctor(module: &elements::Module) -> bool {
-	if let Some(ref section) = module.export_section() {
-		section.entries().iter().any(|e| CREATE_SYMBOL == e.field())
-	} else {
-		false
-	}
-}
-
-fn do_main() -> Result<(), Error> {
-	logger::init_log();
-
-	let matches = App::new("wasm-build")
-		.arg(Arg::with_name("target")
-			.index(1)
-			.required(true)
-			.help("Cargo target directory"))
-		.arg(Arg::with_name("wasm")
-			.index(2)
-			.required(true)
-			.help("Wasm binary name"))
-		.arg(Arg::with_name("skip_optimization")
-			.help("Skip symbol optimization step producing final wasm")
-			.long("skip-optimization"))
-		.arg(Arg::with_name("enforce_stack_adjustment")
-			.help("Enforce stack size adjustment (used for old wasm32-unknown-unknown)")
-			.long("enforce-stack-adjustment"))
-		.arg(Arg::with_name("runtime_type")
-			.help("Injects RUNTIME_TYPE global export")
-			.takes_value(true)
-			.long("runtime-type"))
-		.arg(Arg::with_name("runtime_version")
-			.help("Injects RUNTIME_VERSION global export")
-			.takes_value(true)
-			.long("runtime-version"))
-		.arg(Arg::with_name("source_target")
-			.help("Cargo target type kind ('wasm32-unknown-unknown' or 'wasm32-unknown-emscripten'")
-			.takes_value(true)
-			.long("target"))
-		.arg(Arg::with_name("final_name")
-			.help("Final wasm binary name")
-			.takes_value(true)
-			.long("final"))
-		.arg(Arg::with_name("save_raw")
-			.help("Save intermediate raw bytecode to path")
-			.takes_value(true)
-			.long("save-raw"))
-		.arg(Arg::with_name("shrink_stack")
-			.help("Shrinks the new stack size for wasm32-unknown-unknown")
-			.takes_value(true)
-			.long("shrink-stack"))
-		.get_matches();
-
-    let target_dir = matches.value_of("target").expect("is required; qed");
-    let wasm_binary = matches.value_of("wasm").expect("is required; qed");
-	let mut source_input = source::SourceInput::new(target_dir, wasm_binary);
-
-	let source_target_val = matches.value_of("source_target").unwrap_or_else(|| source::EMSCRIPTEN_TRIPLET);
-	if source_target_val == source::UNKNOWN_TRIPLET {
-		source_input = source_input.unknown()
-	} else if source_target_val == source::EMSCRIPTEN_TRIPLET {
-		source_input = source_input.emscripten()
-	} else {
-		eprintln!("--target can be: '{}' or '{}'", source::EMSCRIPTEN_TRIPLET, source::UNKNOWN_TRIPLET);
-		::std::process::exit(1);
-	}
-
-	if let Some(final_name) = matches.value_of("final_name") {
-		source_input = source_input.with_final(final_name);
-	}
-
-	process_output(&source_input)?;
-
-	let path = wasm_path(&source_input);
-
-	let mut module = parity_wasm::deserialize_file(&path)
-		.map_err(|e| Error::Decoding(e, path.to_string()))?;
-
-	if let source::SourceTarget::Emscripten = source_input.target() {
-		module = ununderscore_funcs(module);
-	}
-
-	if let source::SourceTarget::Unknown = source_input.target() {
-		// 49152 is 48kb!
-		if matches.is_present("enforce_stack_adjustment") {
-			let stack_size: u32 = matches.value_of("shrink_stack").unwrap_or_else(|| "49152").parse().expect("New stack size is not valid u32");
-			assert!(stack_size <= 1024*1024);
-			let (new_module, new_stack_top) = shrink_unknown_stack(module, 1024 * 1024 - stack_size);
-			module = new_module;
-			let mut stack_top_page = new_stack_top / 65536;
-			if new_stack_top % 65536 > 0 { stack_top_page += 1 };
-			module = externalize_mem(module, Some(stack_top_page), 16);
-		} else {
-			module = externalize_mem(module, None, 16);
-		}
-	}
-
-	if let Some(runtime_type) = matches.value_of("runtime_type") {
-		let runtime_type: &[u8] = runtime_type.as_bytes();
-		if runtime_type.len() != 4 {
-			panic!("--runtime-type should be equal to 4 bytes");
-		}
-		let runtime_version: u32 = matches.value_of("runtime_version").unwrap_or("1").parse()
-			.expect("--runtime-version should be a positive integer");
-		module = utils::inject_runtime_type(module, &runtime_type, runtime_version);
-	}
-
-	let mut ctor_module = module.clone();
-
-	if !matches.is_present("skip_optimization") {
-		utils::optimize(
-			&mut module,
-			vec![CALL_SYMBOL]
-		)?;
-	}
-
-	if let Some(save_raw_path) = matches.value_of("save_raw") {
-		parity_wasm::serialize_to_file(save_raw_path, module.clone()).map_err(Error::Encoding)?;
-	}
-
-	let raw_module = parity_wasm::serialize(module).map_err(Error::Encoding)?;
-
-	// If module has an exported function with name=CREATE_SYMBOL
-	// build will pack the module (raw_module) into this funciton and export as CALL_SYMBOL.
-	// Otherwise it will just save an optimised raw_module
-	if has_ctor(&ctor_module) {
-		if !matches.is_present("skip_optimization") {
-			utils::optimize(&mut ctor_module, vec![CREATE_SYMBOL])?;
-		}
-		let ctor_module = utils::pack_instance(raw_module, ctor_module)?;
-		parity_wasm::serialize_to_file(&path, ctor_module).map_err(Error::Encoding)?;
-	} else {
-		let mut file = fs::File::create(&path)?;
-		file.write_all(&raw_module)?;
-	}
-
-	Ok(())
-}
-
-fn main() {
-	if let Err(e) = do_main() {
-		eprintln!("{}", e);
-		std::process::exit(1)
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	extern crate tempdir;
-
-	use self::tempdir::TempDir;
-	use std::fs;
-
-	use super::process_output;
-	use super::source::SourceInput;
-
-	#[test]
-	fn processes_cargo_output() {
-		let tmp_dir = TempDir::new("target").expect("temp dir failed");
-
-		let target_path = tmp_dir.path().join("wasm32-unknown-emscripten").join("release");
-		fs::create_dir_all(target_path.clone()).expect("create dir failed");
-
-		{
-			use std::io::Write;
-
-			let wasm_path = target_path.join("example_wasm.wasm");
-			let mut f = fs::File::create(wasm_path).expect("create fail failed");
-			f.write(b"\0asm").expect("write file failed");
-		}
-
-		let path = tmp_dir.path().to_string_lossy();
-		let input = SourceInput::new(&path, "example-wasm");
-
-		process_output(&input).expect("process output failed");
-
-		assert!(
-			fs::metadata(tmp_dir.path().join("example-wasm.wasm")).expect("metadata failed").is_file()
-		)
-	}
-}

cli/build/source.rs

@@ -1,62 +0,0 @@
-//! Configuration of source binaries
-
-pub const UNKNOWN_TRIPLET: &str = "wasm32-unknown-unknown";
-pub const EMSCRIPTEN_TRIPLET: &str = "wasm32-unknown-emscripten";
-
-/// Target configiration of previous build step
-#[derive(Debug, Clone, Copy)]
-pub enum SourceTarget {
-	Emscripten,
-	Unknown,
-}
-
-/// Configuration of previous build step (cargo compilation)
-#[derive(Debug)]
-pub struct SourceInput<'a> {
-	target_dir: &'a str,
-	bin_name: &'a str,
-	final_name: &'a str,
-	target: SourceTarget,
-}
-
-impl<'a> SourceInput<'a> {
-	pub fn new<'b>(target_dir: &'b str, bin_name: &'b str) -> SourceInput<'b> {
-		SourceInput {
-			target_dir: target_dir,
-			bin_name: bin_name,
-			final_name: bin_name,
-			target: SourceTarget::Emscripten,
-		}
-	}
-
-	pub fn unknown(mut self) -> Self {
-		self.target = SourceTarget::Unknown;
-		self
-	}
-
-	pub fn emscripten(mut self) -> Self {
-		self.target = SourceTarget::Emscripten;
-		self
-	}
-
-	pub fn with_final(mut self, final_name: &'a str) -> Self {
-		self.final_name = final_name;
-		self
-	}
-
-	pub fn target_dir(&self) -> &str {
-		self.target_dir
-	}
-
-	pub fn bin_name(&self) -> &str {
-		self.bin_name
-	}
-
-	pub fn final_name(&self) -> &str {
-		self.final_name
-	}
-
-	pub fn target(&self) -> SourceTarget {
-		self.target
-	}
-}

cli/ext/main.rs

@@ -1,23 +0,0 @@
-extern crate parity_wasm;
-extern crate pwasm_utils as utils;
-extern crate pwasm_utils_cli as logger;
-
-use std::env;
-
-fn main() {
-
-	logger::init_log();
-
-	let args = env::args().collect::<Vec<_>>();
-	if args.len() != 3 {
-		println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
-		return;
-	}
-
-	let module = utils::externalize(
-		parity_wasm::deserialize_file(&args[1]).expect("Module to deserialize ok"),
-		vec!["_free", "_malloc", "_memcpy", "_memset", "_memmove"],
-	);
-
-	parity_wasm::serialize_to_file(&args[2], module).expect("Module to serialize ok");
-}

cli/gas/main.rs

@@ -1,24 +0,0 @@
-extern crate parity_wasm;
-extern crate pwasm_utils as utils;
-extern crate pwasm_utils_cli as logger;
-
-use std::env;
-
-fn main() {
-	logger::init_log();
-
-	let args = env::args().collect::<Vec<_>>();
-	if args.len() != 3 {
-		println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
-		return;
-	}
-
-	// Loading module
-	let module = parity_wasm::deserialize_file(&args[1]).expect("Module deserialization to succeed");
-
-	let result = utils::inject_gas_counter(
-		module, &Default::default()
-	).expect("Failed to inject gas. Some forbidden opcodes?");
-
-	parity_wasm::serialize_to_file(&args[2], result).expect("Module serialization to succeed")
-}

cli/prune/main.rs

@@ -1,45 +0,0 @@
-extern crate parity_wasm;
-extern crate pwasm_utils as utils;
-extern crate pwasm_utils_cli as logger;
-extern crate clap;
-
-use clap::{App, Arg};
-
-fn main() {
-    logger::init_log();
-
-    let matches = App::new("wasm-opt")
-                        .arg(Arg::with_name("input")
-                            .index(1)
-                            .required(true)
-                            .help("Input WASM file"))
-                        .arg(Arg::with_name("output")
-                            .index(2)
-                            .required(true)
-                            .help("Output WASM file"))
-                        .arg(Arg::with_name("exports")
-                            .long("exports")
-                            .short("e")
-                            .takes_value(true)
-                            .value_name("functions")
-                            .help("Comma-separated list of exported functions to keep. Default: _call"))
-                        .get_matches();
-
-    let exports = matches
-                    .value_of("exports")
-                    .unwrap_or("_call")
-                    .split(',')
-                    .collect();
-
-    let input = matches.value_of("input").expect("is required; qed");
-    let output = matches.value_of("output").expect("is required; qed");
-
-    let mut module = parity_wasm::deserialize_file(&input).unwrap();
-
-    // Invoke optimizer
-    //   Contract is supposed to have only these functions as public api
-    //   All other symbols not usable by this list is optimized away
-    utils::optimize(&mut module, exports).expect("Optimizer to finish without errors");
-
-    parity_wasm::serialize_to_file(&output, module).unwrap();
-}

cli/src/lib.rs

@@ -1,27 +0,0 @@
-#[macro_use] extern crate log;
-#[macro_use] extern crate lazy_static;
-extern crate env_logger;
-
-use std::env;
-use log::LevelFilter;
-use env_logger::Builder;
-
-lazy_static! {
-	static ref LOG_DUMMY: bool = {
-		let mut builder = Builder::new();
-		builder.filter(None, LevelFilter::Info);
-
-		if let Ok(log) = env::var("RUST_LOG") {
-			builder.parse(&log);
-		}
-
-		builder.init();
-		trace!("logger initialized");
-		true
-	};
-}
-
-/// Intialize log with default settings
-pub fn init_log() {
-	let _ = *LOG_DUMMY;
-}

cli/stack_height/main.rs

@@ -1,28 +0,0 @@
-extern crate pwasm_utils as utils;
-extern crate parity_wasm;
-extern crate pwasm_utils_cli as logger;
-
-use std::env;
-use utils::stack_height;
-
-fn main() {
-	logger::init_log();
-
-	let args = env::args().collect::<Vec<_>>();
-	if args.len() != 3 {
-		println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
-		return;
-	}
-
-	let input_file = &args[1];
-	let output_file = &args[2];
-
-	// Loading module
-	let module = parity_wasm::deserialize_file(&input_file).expect("Module deserialization to succeed");
-
-	let result = stack_height::inject_limiter(
-		module, 1024
-	).expect("Failed to inject stack height counter");
-
-	parity_wasm::serialize_to_file(&output_file, result).expect("Module serialization to succeed")
-}

justfile

@@ -0,0 +1,18 @@
+_default:
+    just --list
+
+# Run rustfmt and ensure the code meets the expectation of the checks in the CI
+format:
+    cargo +nightly fmt --all
+
+# Run basic checks similar to what the CI does to ensure your code is fine
+check:
+    cargo +nightly fmt --all -- --check
+    cargo +stable clippy --all-targets --all-features -- -D warnings
+
+# Run the tests
+test:
+    cargo test --all-features
+
+# So you are ready? This runs format, check and test
+ready: format check test

rustfmt.toml

@@ -0,0 +1,23 @@
+# Basic
+hard_tabs = true
+max_width = 100
+use_small_heuristics = "Max"
+# Imports
+imports_granularity = "Crate"
+reorder_imports = true
+# Consistency
+newline_style = "Unix"
+# Format comments
+comment_width = 100
+wrap_comments = true
+# Misc
+chain_width = 80
+spaces_around_ranges = false
+binop_separator = "Back"
+reorder_impl_items = false
+match_arm_leading_pipes = "Preserve"
+match_arm_blocks = false
+match_block_trailing_comma = true
+trailing_comma = "Vertical"
+trailing_semicolon = false
+use_field_init_shorthand = true

src/export_globals.rs

@@ -0,0 +1,161 @@
+use alloc::{format, vec::Vec};
+use parity_wasm::elements;
+
+/// Export all declared mutable globals as `prefix_index`.
+///
+/// This will export all internal mutable globals under the name of
+/// concat(`prefix`, `"_"`, `i`) where i is the index inside the range of
+/// [0..total number of internal mutable globals].
+pub fn export_mutable_globals(module: &mut elements::Module, prefix: &str) {
+	let exports = global_section(module)
+		.map(|section| {
+			section
+				.entries()
+				.iter()
+				.enumerate()
+				.filter_map(
+					|(index, global)| {
+						if global.global_type().is_mutable() {
+							Some(index)
+						} else {
+							None
+						}
+					},
+				)
+				.collect::<Vec<_>>()
+		})
+		.unwrap_or_default();
+
+	if module.export_section().is_none() {
+		module
+			.sections_mut()
+			.push(elements::Section::Export(elements::ExportSection::default()));
+	}
+
+	for (symbol_index, export) in exports.into_iter().enumerate() {
+		let new_entry = elements::ExportEntry::new(
+			format!("{}_{}", prefix, symbol_index),
+			elements::Internal::Global(
+				(module.import_count(elements::ImportCountType::Global) + export) as _,
+			),
+		);
+		export_section(module)
+			.expect("added above if does not exists")
+			.entries_mut()
+			.push(new_entry);
+	}
+}
+
+fn export_section(module: &mut elements::Module) -> Option<&mut elements::ExportSection> {
+	for section in module.sections_mut() {
+		if let elements::Section::Export(sect) = section {
+			return Some(sect)
+		}
+	}
+	None
+}
+
+fn global_section(module: &mut elements::Module) -> Option<&mut elements::GlobalSection> {
+	for section in module.sections_mut() {
+		if let elements::Section::Global(sect) = section {
+			return Some(sect)
+		}
+	}
+	None
+}
+
+#[cfg(test)]
+mod tests {
+
+	use super::export_mutable_globals;
+	use parity_wasm::elements;
+
+	fn parse_wat(source: &str) -> elements::Module {
+		let module_bytes = wat::parse_str(source).unwrap();
+		wasmparser::validate(&module_bytes).unwrap();
+		elements::deserialize_buffer(module_bytes.as_ref()).expect("failed to parse module")
+	}
+
+	macro_rules! test_export_global {
+		(name = $name:ident; input = $input:expr; expected = $expected:expr) => {
+			#[test]
+			fn $name() {
+				let mut input_module = parse_wat($input);
+				let expected_module = parse_wat($expected);
+
+				export_mutable_globals(&mut input_module, "exported_internal_global");
+
+				let actual_bytes = elements::serialize(input_module)
+					.expect("injected module must have a function body");
+
+				let expected_bytes = elements::serialize(expected_module)
+					.expect("injected module must have a function body");
+
+				let actual_wat = wasmprinter::print_bytes(actual_bytes).unwrap();
+				let expected_wat = wasmprinter::print_bytes(expected_bytes).unwrap();
+
+				if actual_wat != expected_wat {
+					for diff in diff::lines(&expected_wat, &actual_wat) {
+						match diff {
+							diff::Result::Left(l) => println!("-{}", l),
+							diff::Result::Both(l, _) => println!(" {}", l),
+							diff::Result::Right(r) => println!("+{}", r),
+						}
+					}
+					panic!()
+				}
+			}
+		};
+	}
+
+	test_export_global! {
+		name = simple;
+		input = r#"
+		(module
+			(global (;0;) (mut i32) (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0)))
+		"#;
+		expected = r#"
+		(module
+			(global (;0;) (mut i32) (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0))
+			(export "exported_internal_global_0" (global 0))
+			(export "exported_internal_global_1" (global 1)))
+		"#
+	}
+
+	test_export_global! {
+		name = with_import;
+		input = r#"
+		(module
+			(import "env" "global" (global $global i64))
+			(global (;0;) (mut i32) (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0)))
+		"#;
+		expected = r#"
+		(module
+			(import "env" "global" (global $global i64))
+			(global (;0;) (mut i32) (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0))
+			(export "exported_internal_global_0" (global 1))
+			(export "exported_internal_global_1" (global 2)))
+		"#
+	}
+
+	test_export_global! {
+		name = with_import_and_some_are_immutable;
+		input = r#"
+		(module
+			(import "env" "global" (global $global i64))
+			(global (;0;) i32 (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0)))
+		"#;
+		expected = r#"
+		(module
+			(import "env" "global" (global $global i64))
+			(global (;0;) i32 (i32.const 1))
+			(global (;1;) (mut i32) (i32.const 0))
+			(export "exported_internal_global_0" (global 2)))
+		"#
+	}
+}

src/ext.rs

@@ -1,207 +0,0 @@
-use std::string::String;
-use std::vec::Vec;
-use std::borrow::ToOwned;
-
-use parity_wasm::{elements, builder};
-use optimizer::{import_section, export_section};
-use byteorder::{LittleEndian, ByteOrder};
-
-type Insertion = (usize, u32, u32, String);
-
-pub fn update_call_index(opcodes: &mut elements::Opcodes, original_imports: usize, inserts: &[Insertion]) {
-	use parity_wasm::elements::Opcode::*;
-	for opcode in opcodes.elements_mut().iter_mut() {
-		match opcode {
-			&mut Call(ref mut call_index) => {
-				if let Some(pos) = inserts.iter().position(|x| x.1 == *call_index) {
-					*call_index = (original_imports + pos) as u32;
-				} else if *call_index as usize > original_imports {
-					*call_index += inserts.len() as u32;
-				}
-			},
-			_ => { }
-		}
-	}
-}
-
-pub fn memory_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::MemorySection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Memory(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn externalize_mem(mut module: elements::Module, adjust_pages: Option<u32>, max_pages: u32) -> elements::Module {
-	let mut entry = memory_section(&mut module)
-		.expect("Memory section to exist")
-		.entries_mut()
-		.pop()
-		.expect("Own memory entry to exist in memory section");
-
-	if let Some(adjust_pages) = adjust_pages {
-		assert!(adjust_pages <= max_pages);
-		entry = elements::MemoryType::new(adjust_pages, Some(max_pages));
-	}
-
-	if entry.limits().maximum().is_none() {
-		entry = elements::MemoryType::new(entry.limits().initial(), Some(max_pages));
-	}
-
-	let mut builder = builder::from_module(module);
-	builder.push_import(
-		elements::ImportEntry::new(
-			"env".to_owned(),
-			"memory".to_owned(),
-			elements::External::Memory(entry),
-		)
-	);
-
-	builder.build()
-}
-
-fn foreach_public_func_name<F>(mut module: elements::Module, f: F) -> elements::Module
-where F: Fn(&mut String)
-{
-	import_section(&mut module).map(|is| {
-		for entry in is.entries_mut() {
-			if let elements::External::Function(_) = *entry.external() {
-				f(entry.field_mut())
-			}
-		}
-	});
-
-	export_section(&mut module).map(|es| {
-		for entry in es.entries_mut() {
-			if let elements::Internal::Function(_) = *entry.internal() {
-				f(entry.field_mut())
-			}
-		}
-	});
-
-	module
-}
-
-pub fn underscore_funcs(module: elements::Module) -> elements::Module {
-	foreach_public_func_name(module, |n| n.insert(0, '_'))
-}
-
-pub fn ununderscore_funcs(module: elements::Module) -> elements::Module {
-	foreach_public_func_name(module, |n| { n.remove(0); })
-}
-
-pub fn shrink_unknown_stack(
-	mut module: elements::Module,
-	// for example, `shrink_amount = (1MB - 64KB)` will limit stack to 64KB
-	shrink_amount: u32,
-) -> (elements::Module, u32) {
-	let mut new_stack_top = 0;
-	for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Data(ref mut data_section) => {
-				for ref mut data_segment in data_section.entries_mut() {
-					if data_segment.offset().code() == &[elements::Opcode::I32Const(4), elements::Opcode::End] {
-						assert_eq!(data_segment.value().len(), 4);
-						let current_val = LittleEndian::read_u32(data_segment.value());
-						let new_val = current_val - shrink_amount;
-						LittleEndian::write_u32(data_segment.value_mut(), new_val);
-						new_stack_top = new_val;
-					}
-				}
-			},
-			_ => continue
-		}
-	}
-	(module, new_stack_top)
-}
-
-pub fn externalize(
-	module: elements::Module,
-	replaced_funcs: Vec<&str>,
-) -> elements::Module {
-   // Save import functions number for later
-	let import_funcs_total = module
-		.import_section().expect("Import section to exist")
-		.entries()
-		.iter()
-		.filter(|e| if let &elements::External::Function(_) = e.external() { true } else { false })
-		.count();
-
-	// First, we find functions indices that are to be rewired to externals
-	//   Triple is (function_index (callable), type_index, function_name)
-	let mut replaces: Vec<Insertion> = replaced_funcs
-		.into_iter()
-		.filter_map(|f| {
-			let export = module
-				.export_section().expect("Export section to exist")
-				.entries().iter().enumerate()
-				.find(|&(_, entry)| entry.field() == f)
-				.expect("All functions of interest to exist");
-
-			if let &elements::Internal::Function(func_idx) = export.1.internal() {
-				let type_ref = module
-					.function_section().expect("Functions section to exist")
-					.entries()[func_idx as usize - import_funcs_total]
-					.type_ref();
-
-				Some((export.0, func_idx, type_ref, export.1.field().to_owned()))
-			} else {
-				None
-			}
-		})
-		.collect();
-
-	replaces.sort_by_key(|e| e.0);
-
-	// Second, we duplicate them as import definitions
-	let mut mbuilder = builder::from_module(module);
-	for &(_, _, type_ref, ref field) in replaces.iter() {
-		mbuilder.push_import(
-			builder::import()
-				.module("env")
-				.field(field)
-				.external().func(type_ref)
-				.build()
-		);
-	}
-
-	// Back to mutable access
-	let mut module = mbuilder.build();
-
-	// Third, rewire all calls to imported functions and update all other calls indices
-	for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Code(ref mut code_section) => {
-				for ref mut func_body in code_section.bodies_mut() {
-					update_call_index(func_body.code_mut(), import_funcs_total, &replaces);
-				}
-			},
-			&mut elements::Section::Export(ref mut export_section) => {
-				for ref mut export in export_section.entries_mut() {
-					match export.internal_mut() {
-						&mut elements::Internal::Function(ref mut func_index) => {
-							if *func_index >= import_funcs_total as u32 { *func_index += replaces.len() as u32; }
-						},
-						_ => {}
-					}
-				}
-			},
-			&mut elements::Section::Element(ref mut elements_section) => {
-				for ref mut segment in elements_section.entries_mut() {
-					// update all indirect call addresses initial values
-					for func_index in segment.members_mut() {
-						if *func_index >= import_funcs_total as u32 { *func_index += replaces.len() as u32; }
-					}
-				}
-			},
-			_ => { }
-		}
-	}
-
-	module
-
-}

src/gas.rs

@@ -1,614 +0,0 @@
-use std::vec::Vec;
-
-use parity_wasm::{elements, builder};
-use rules;
-
-pub fn update_call_index(opcodes: &mut elements::Opcodes, inserted_index: u32) {
-	use parity_wasm::elements::Opcode::*;
-	for opcode in opcodes.elements_mut().iter_mut() {
-		match opcode {
-			&mut Call(ref mut call_index) => {
-				if *call_index >= inserted_index { *call_index += 1}
-			},
-			_ => { },
-		}
-	}
-}
-
-/// A block of code represented by it's start position and cost.
-///
-/// The block typically starts with instructions such as `loop`, `block`, `if`, etc.
-///
-/// An example of block:
-///
-/// ```ignore
-/// loop
-///   i32.const 1
-///   get_local 0
-///   i32.sub
-///   tee_local 0
-///   br_if 0
-/// end
-/// ```
-///
-/// The start of the block is `i32.const 1`.
-///
-#[derive(Debug)]
-struct BlockEntry {
-	/// Index of the first instruction (aka `Opcode`) in the block.
-	start_pos: usize,
-	/// Sum of costs of all instructions until end of the block.
-	cost: u32,
-}
-
-struct Counter {
-	/// All blocks in the order of theirs start position.
-	blocks: Vec<BlockEntry>,
-
-	// Stack of blocks. Each element is an index to a `self.blocks` vector.
-	stack: Vec<usize>,
-}
-
-impl Counter {
-	fn new() -> Counter {
-		Counter {
-			stack: Vec::new(),
-			blocks: Vec::new(),
-		}
-	}
-
-	/// Begin a new block.
-	fn begin(&mut self, cursor: usize) {
-		let block_idx = self.blocks.len();
-		self.blocks.push(BlockEntry {
-			start_pos: cursor,
-			cost: 1,
-		});
-		self.stack.push(block_idx);
-	}
-
-	/// Finalize the current block.
-	///
-	/// Finalized blocks have final cost which will not change later.
-	fn finalize(&mut self) -> Result<(), ()> {
-		self.stack.pop().ok_or_else(|| ())?;
-		Ok(())
-	}
-
-	/// Increment the cost of the current block by the specified value.
-	fn increment(&mut self, val: u32) -> Result<(), ()> {
-		let stack_top = self.stack.last_mut().ok_or_else(|| ())?;
-		let top_block = self.blocks.get_mut(*stack_top).ok_or_else(|| ())?;
-
-		top_block.cost = top_block.cost.checked_add(val).ok_or_else(|| ())?;
-
-		Ok(())
-	}
-}
-
-fn inject_grow_counter(opcodes: &mut elements::Opcodes, grow_counter_func: u32) -> usize {
-	use parity_wasm::elements::Opcode::*;
-	let mut counter = 0;
-	for opcode in opcodes.elements_mut() {
-		match *opcode {
-			GrowMemory(_) => {
-				*opcode = Call(grow_counter_func);
-				counter += 1;
-			},
-			_ => {}
-		}
-	}
-	counter
-}
-
-fn add_grow_counter(module: elements::Module, rules: &rules::Set, gas_func: u32) -> elements::Module {
-	use parity_wasm::elements::Opcode::*;
-
-	let mut b = builder::from_module(module);
-	b.push_function(
-		builder::function()
-			.signature().params().i32().build().with_return_type(Some(elements::ValueType::I32)).build()
-			.body()
-				.with_opcodes(elements::Opcodes::new(vec![
-					GetLocal(0),
-					GetLocal(0),
-					I32Const(rules.grow_cost() as i32),
-					I32Mul,
-					// todo: there should be strong guarantee that it does not return anything on stack?
-					Call(gas_func),
-					GrowMemory(0),
-					End,
-				]))
-				.build()
-			.build()
-	);
-
-	b.build()
-}
-
-pub fn inject_counter(
-	opcodes: &mut elements::Opcodes,
-	rules: &rules::Set,
-	gas_func: u32,
-) -> Result<(), ()> {
-	use parity_wasm::elements::Opcode::*;
-
-	let mut counter = Counter::new();
-
-	// Begin an implicit function (i.e. `func...end`) block.
-	counter.begin(0);
-
-	for cursor in 0..opcodes.elements().len() {
-		let opcode = &opcodes.elements()[cursor];
-		match *opcode {
-			Block(_) | If(_) | Loop(_) => {
-				// Increment previous block with the cost of the current opcode.
-				let opcode_cost = rules.process(opcode)?;
-				counter.increment(opcode_cost)?;
-
-				// Begin new block. The cost of the following opcodes until `End` or `Else` will
-				// be included into this block.
-				counter.begin(cursor + 1);
-			}
-			End => {
-				// Just finalize current block.
-				counter.finalize()?;
-			},
-			Else => {
-				// `Else` opcode is being encountered. So the case we are looking at:
-				//
-				// if
-				//   ...
-				// else <-- cursor
-				//   ...
-				// end
-				//
-				// Finalize the current block ('then' part of the if statement),
-				// and begin another one for the 'else' part.
-				counter.finalize()?;
-				counter.begin(cursor + 1);
-			}
-			_ => {
-				// An ordinal non control flow instruction. Just increment the cost of the current block.
-				let opcode_cost = rules.process(opcode)?;
-				counter.increment(opcode_cost)?;
-			}
-		}
-	}
-
-	// Then insert metering calls.
-	let mut cumulative_offset = 0;
-	for block in counter.blocks {
-		let effective_pos = block.start_pos + cumulative_offset;
-
-		opcodes.elements_mut().insert(effective_pos, I32Const(block.cost as i32));
-		opcodes.elements_mut().insert(effective_pos+1, Call(gas_func));
-
-		// Take into account these two inserted instructions.
-		cumulative_offset += 2;
-	}
-
-	Ok(())
-}
-
-/// Injects gas counter.
-///
-/// Can only fail if encounters operation forbidden by gas rules,
-/// in this case it returns error with the original module.
-pub fn inject_gas_counter(module: elements::Module, rules: &rules::Set)
-	-> Result<elements::Module, elements::Module>
-{
-	// Injecting gas counting external
-	let mut mbuilder = builder::from_module(module);
-	let import_sig = mbuilder.push_signature(
-		builder::signature()
-			.param().i32()
-			.build_sig()
-		);
-
-	mbuilder.push_import(
-		builder::import()
-			.module("env")
-			.field("gas")
-			.external().func(import_sig)
-			.build()
-		);
-
-	// back to plain module
-	let mut module = mbuilder.build();
-
-	// calculate actual function index of the imported definition
-	//    (substract all imports that are NOT functions)
-
-	let gas_func = module.import_count(elements::ImportCountType::Function) as u32 - 1;
-	let total_func = module.functions_space() as u32;
-	let mut need_grow_counter = false;
-	let mut error = false;
-
-	// Updating calling addresses (all calls to function index >= `gas_func` should be incremented)
-	for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Code(ref mut code_section) => {
-				for ref mut func_body in code_section.bodies_mut() {
-					update_call_index(func_body.code_mut(), gas_func);
-					if let Err(_) = inject_counter(func_body.code_mut(), rules, gas_func) {
-						error = true;
-						break;
-					}
-					if rules.grow_cost() > 0 {
-						if inject_grow_counter(func_body.code_mut(), total_func) > 0 {
-							need_grow_counter = true;
-						}
-					}
-				}
-			},
-			&mut elements::Section::Export(ref mut export_section) => {
-				for ref mut export in export_section.entries_mut() {
-					match export.internal_mut() {
-						&mut elements::Internal::Function(ref mut func_index) => {
-							if *func_index >= gas_func { *func_index += 1}
-						},
-						_ => {}
-					}
-				}
-			},
-			&mut elements::Section::Element(ref mut elements_section) => {
-				for ref mut segment in elements_section.entries_mut() {
-					// update all indirect call addresses initial values
-					for func_index in segment.members_mut() {
-						if *func_index >= gas_func { *func_index += 1}
-					}
-				}
-			},
-			_ => { }
-		}
-	}
-
-	if error { return Err(module); }
-
-	if need_grow_counter { Ok(add_grow_counter(module, rules, gas_func)) } else { Ok(module) }
-}
-
-#[cfg(test)]
-mod tests {
-
-	extern crate wabt;
-
-	use parity_wasm::{serialize, builder, elements};
-	use super::*;
-	use rules;
-
-	#[test]
-	fn simple_grow() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							GetGlobal(0),
-							GrowMemory(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &rules::Set::default().with_grow_cost(10000)).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(3),
-				Call(0),
-				GetGlobal(0),
-				Call(2),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[0]
-				.code().elements()
-		);
-		assert_eq!(
-			&vec![
-				GetLocal(0),
-				GetLocal(0),
-				I32Const(10000),
-				I32Mul,
-				Call(0),
-				GrowMemory(0),
-				End,
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[1]
-				.code().elements()
-		);
-
-		let binary = serialize(injected_module).expect("serialization failed");
-		self::wabt::wasm2wat(&binary).unwrap();
-	}
-
-	#[test]
-	fn grow_no_gas_no_track() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							GetGlobal(0),
-							GrowMemory(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &rules::Set::default()).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(3),
-				Call(0),
-				GetGlobal(0),
-				GrowMemory(0),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[0]
-				.code().elements()
-		);
-
-		assert_eq!(injected_module.functions_space(), 2);
-
-		let binary = serialize(injected_module).expect("serialization failed");
-		self::wabt::wasm2wat(&binary).unwrap();
-	}
-
-	#[test]
-	fn simple() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							GetGlobal(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &Default::default()).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(2),
-				Call(0),
-				GetGlobal(0),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[0]
-				.code().elements()
-		);
-	}
-
-	#[test]
-	fn nested() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							GetGlobal(0),
-							Block(elements::BlockType::NoResult),
-								GetGlobal(0),
-								GetGlobal(0),
-								GetGlobal(0),
-							End,
-							GetGlobal(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &Default::default()).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(4),
-				Call(0),
-				GetGlobal(0),
-				Block(elements::BlockType::NoResult),
-					I32Const(4),
-					Call(0),
-					GetGlobal(0),
-					GetGlobal(0),
-					GetGlobal(0),
-				End,
-				GetGlobal(0),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[0]
-				.code().elements()
-		);
-	}
-
-	#[test]
-	fn ifelse() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							GetGlobal(0),
-							If(elements::BlockType::NoResult),
-								GetGlobal(0),
-								GetGlobal(0),
-								GetGlobal(0),
-							Else,
-								GetGlobal(0),
-								GetGlobal(0),
-							End,
-							GetGlobal(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &Default::default()).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(4),
-				Call(0),
-				GetGlobal(0),
-				If(elements::BlockType::NoResult),
-					I32Const(4),
-					Call(0),
-					GetGlobal(0),
-					GetGlobal(0),
-					GetGlobal(0),
-				Else,
-					I32Const(3),
-					Call(0),
-					GetGlobal(0),
-					GetGlobal(0),
-				End,
-				GetGlobal(0),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[0]
-				.code().elements()
-		);
-	}
-
-	#[test]
-	fn call_index() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body().build()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							Call(0),
-							If(elements::BlockType::NoResult),
-								Call(0),
-								Call(0),
-								Call(0),
-							Else,
-								Call(0),
-								Call(0),
-							End,
-							Call(0),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let injected_module = inject_gas_counter(module, &Default::default()).unwrap();
-
-		assert_eq!(
-			&vec![
-				I32Const(4),
-				Call(0),
-				Call(1),
-				If(elements::BlockType::NoResult),
-					I32Const(4),
-					Call(0),
-					Call(1),
-					Call(1),
-					Call(1),
-				Else,
-					I32Const(3),
-					Call(0),
-					Call(1),
-					Call(1),
-				End,
-				Call(1),
-				End
-			][..],
-			injected_module
-				.code_section().expect("function section should exist").bodies()[1]
-				.code().elements()
-		);
-	}
-
-
-	#[test]
-	fn forbidden() {
-		use parity_wasm::elements::Opcode::*;
-
-		let module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							F32Const(555555),
-							End
-						]
-					))
-					.build()
-				.build()
-			.build();
-
-		let rules = rules::Set::default().with_forbidden_floats();
-
-		if let Err(_) = inject_gas_counter(module, &rules) { }
-		else { panic!("Should be error because of the forbidden operation")}
-
-	}
-
-}

src/gas_metering/backend.rs

@@ -0,0 +1,139 @@
+//! Provides backends for the gas metering instrumentation
+use parity_wasm::elements;
+
+/// Implementation details of the specific method of the gas metering.
+#[derive(Clone)]
+pub enum GasMeter {
+	/// Gas metering with an external function.
+	External {
+		/// Name of the module to import the gas function from.
+		module: &'static str,
+		/// Name of the external gas function to be imported.
+		function: &'static str,
+	},
+	/// Gas metering with a local function and a mutable global.
+	Internal {
+		/// Name of the mutable global to be exported.
+		global: &'static str,
+		/// Body of the local gas counting function to be injected.
+		func_instructions: elements::Instructions,
+		/// Cost of the gas function execution.
+		cost: u64,
+	},
+}
+
+use super::Rules;
+/// Under the hood part of the gas metering mechanics.
+pub trait Backend {
+	/// Provides the gas metering implementation details.  
+	fn gas_meter<R: Rules>(self, module: &elements::Module, rules: &R) -> GasMeter;
+}
+
+/// Gas metering with an external host function.
+pub mod host_function {
+	use super::{Backend, GasMeter, Rules};
+	use parity_wasm::elements::Module;
+	/// Injects invocations of the gas charging host function into each metering block.
+	pub struct Injector {
+		/// The name of the module to import the gas function from.
+		module: &'static str,
+		/// The name of the gas function to import.
+		name: &'static str,
+	}
+
+	impl Injector {
+		pub fn new(module: &'static str, name: &'static str) -> Self {
+			Self { module, name }
+		}
+	}
+
+	impl Backend for Injector {
+		fn gas_meter<R: Rules>(self, _module: &Module, _rules: &R) -> GasMeter {
+			GasMeter::External { module: self.module, function: self.name }
+		}
+	}
+}
+
+/// Gas metering with a mutable global.
+///
+/// # Note
+///
+/// Not for all execution engines this method gives performance wins compared to using an [external
+/// host function](host_function). See benchmarks and size overhead tests for examples of how to
+/// make measurements needed to decide which gas metering method is better for your particular case.
+///
+/// # Warning
+///
+/// It is not recommended to apply [stack limiter](crate::inject_stack_limiter) instrumentation to a
+/// module instrumented with this type of gas metering. This could lead to a massive module size
+/// bloat. This is a known issue to be fixed in upcoming versions.
+pub mod mutable_global {
+	use super::{Backend, GasMeter, Rules};
+	use alloc::vec;
+	use parity_wasm::elements::{self, Instruction, Module};
+	/// Injects a mutable global variable and a local function to the module to track
+	/// current gas left.
+	///
+	/// The function is called in every metering block. In case of falling out of gas, the global is
+	/// set to the sentinel value `U64::MAX` and `unreachable` instruction is called. The execution
+	/// engine should take care of getting the current global value and setting it back in order to
+	/// sync the gas left value during an execution.
+	pub struct Injector {
+		/// The export name of the gas tracking global.
+		pub global_name: &'static str,
+	}
+
+	impl Injector {
+		pub fn new(global_name: &'static str) -> Self {
+			Self { global_name }
+		}
+	}
+
+	impl Backend for Injector {
+		fn gas_meter<R: Rules>(self, module: &Module, rules: &R) -> GasMeter {
+			let gas_global_idx = module.globals_space() as u32;
+
+			let func_instructions = vec![
+				Instruction::GetGlobal(gas_global_idx),
+				Instruction::GetLocal(0),
+				Instruction::I64GeU,
+				Instruction::If(elements::BlockType::NoResult),
+				Instruction::GetGlobal(gas_global_idx),
+				Instruction::GetLocal(0),
+				Instruction::I64Sub,
+				Instruction::SetGlobal(gas_global_idx),
+				Instruction::Else,
+				// sentinel val u64::MAX
+				Instruction::I64Const(-1i64),           // non-charged instruction
+				Instruction::SetGlobal(gas_global_idx), // non-charged instruction
+				Instruction::Unreachable,               // non-charged instruction
+				Instruction::End,
+				Instruction::End,
+			];
+
+			// calculate gas used for the gas charging func execution itself
+			let mut gas_fn_cost = func_instructions.iter().fold(0, |cost: u64, instruction| {
+				cost.saturating_add(rules.instruction_cost(instruction).unwrap_or(u32::MAX).into())
+			});
+			// don't charge for the instructions used to fail when out of gas
+			let fail_cost = [
+				Instruction::I64Const(-1i64),           // non-charged instruction
+				Instruction::SetGlobal(gas_global_idx), // non-charged instruction
+				Instruction::Unreachable,               // non-charged instruction
+			]
+			.iter()
+			.fold(0, |cost: u64, instruction| {
+				cost.saturating_add(rules.instruction_cost(instruction).unwrap_or(u32::MAX).into())
+			});
+
+			// the fail costs are a subset of the overall costs and hence this never underflows
+			gas_fn_cost -= fail_cost;
+
+			GasMeter::Internal {
+				global: self.global_name,
+				func_instructions: elements::Instructions::new(func_instructions),
+				cost: gas_fn_cost,
+			}
+		}
+	}
+}

src/gas_metering/validation.rs

@@ -0,0 +1,367 @@
+//! This module is used to validate the correctness of the gas metering algorithm.
+//!
+//! Since the gas metering algorithm is complex, this checks correctness by fuzzing. The testing
+//! strategy is to generate random, valid Wasm modules using Binaryen's translate-to-fuzz
+//! functionality, then ensure for all functions defined, in all execution paths though the
+//! function body that do not trap that the amount of gas charged by the proposed metering
+//! instructions is correct. This is done by constructing a control flow graph and exhaustively
+//! searching through all paths, which may take exponential time in the size of the function body in
+//! the worst case.
+
+use super::{ConstantCostRules, MeteredBlock, Rules};
+use parity_wasm::elements::{FuncBody, Instruction};
+use std::collections::BTreeMap as Map;
+
+/// An ID for a node in a ControlFlowGraph.
+type NodeId = usize;
+
+/// A node in a control flow graph is commonly known as a basic block. This is a sequence of
+/// operations that are always executed sequentially.
+#[derive(Debug, Default)]
+struct ControlFlowNode {
+	/// The index of the first instruction in the basic block. This is only used for debugging.
+	first_instr_pos: Option<usize>,
+
+	/// The actual gas cost of executing all instructions in the basic block.
+	actual_cost: u64,
+
+	/// The amount of gas charged by the injected metering instructions within this basic block.
+	charged_cost: u64,
+
+	/// Whether there are any other nodes in the graph that loop back to this one. Every cycle in
+	/// the control flow graph contains at least one node with this flag set.
+	is_loop_target: bool,
+
+	/// Edges in the "forward" direction of the graph. The graph of nodes and their forward edges
+	/// forms a directed acyclic graph (DAG).
+	forward_edges: Vec<NodeId>,
+
+	/// Edges in the "backwards" direction. These edges form cycles in the graph.
+	loopback_edges: Vec<NodeId>,
+}
+
+/// A control flow graph where nodes are basic blocks and edges represent possible transitions
+/// between them in execution flow. The graph has two types of edges, forward and loop-back edges.
+/// The subgraph with only the forward edges forms a directed acyclic graph (DAG); including the
+/// loop-back edges introduces cycles.
+#[derive(Debug)]
+pub struct ControlFlowGraph {
+	nodes: Vec<ControlFlowNode>,
+}
+
+impl ControlFlowGraph {
+	fn new() -> Self {
+		ControlFlowGraph { nodes: Vec::new() }
+	}
+
+	fn get_node(&self, node_id: NodeId) -> &ControlFlowNode {
+		self.nodes.get(node_id).unwrap()
+	}
+
+	fn get_node_mut(&mut self, node_id: NodeId) -> &mut ControlFlowNode {
+		self.nodes.get_mut(node_id).unwrap()
+	}
+
+	fn add_node(&mut self) -> NodeId {
+		self.nodes.push(ControlFlowNode::default());
+		self.nodes.len() - 1
+	}
+
+	fn increment_actual_cost(&mut self, node_id: NodeId, cost: u32) {
+		self.get_node_mut(node_id).actual_cost += u64::from(cost);
+	}
+
+	fn increment_charged_cost(&mut self, node_id: NodeId, cost: u64) {
+		self.get_node_mut(node_id).charged_cost += cost;
+	}
+
+	fn set_first_instr_pos(&mut self, node_id: NodeId, first_instr_pos: usize) {
+		self.get_node_mut(node_id).first_instr_pos = Some(first_instr_pos)
+	}
+
+	fn new_edge(&mut self, from_id: NodeId, target_frame: &ControlFrame) {
+		if target_frame.is_loop {
+			self.new_loopback_edge(from_id, target_frame.entry_node);
+		} else {
+			self.new_forward_edge(from_id, target_frame.exit_node);
+		}
+	}
+
+	fn new_forward_edge(&mut self, from_id: NodeId, to_id: NodeId) {
+		self.get_node_mut(from_id).forward_edges.push(to_id)
+	}
+
+	fn new_loopback_edge(&mut self, from_id: NodeId, to_id: NodeId) {
+		self.get_node_mut(from_id).loopback_edges.push(to_id);
+		self.get_node_mut(to_id).is_loop_target = true;
+	}
+}
+
+/// A control frame is opened upon entry into a function and by the `block`, `if`, and `loop`
+/// instructions and is closed by `end` instructions.
+struct ControlFrame {
+	is_loop: bool,
+	entry_node: NodeId,
+	exit_node: NodeId,
+	active_node: NodeId,
+}
+
+impl ControlFrame {
+	fn new(entry_node_id: NodeId, exit_node_id: NodeId, is_loop: bool) -> Self {
+		ControlFrame {
+			is_loop,
+			entry_node: entry_node_id,
+			exit_node: exit_node_id,
+			active_node: entry_node_id,
+		}
+	}
+}
+
+/// Construct a control flow graph from a function body and the metered blocks computed for it.
+///
+/// This assumes that the function body has been validated already, otherwise this may panic.
+fn build_control_flow_graph(
+	body: &FuncBody,
+	rules: &impl Rules,
+	blocks: &[MeteredBlock],
+) -> Result<ControlFlowGraph, ()> {
+	let mut graph = ControlFlowGraph::new();
+
+	let entry_node_id = graph.add_node();
+	let terminal_node_id = graph.add_node();
+
+	graph.set_first_instr_pos(entry_node_id, 0);
+
+	let mut stack = vec![ControlFrame::new(entry_node_id, terminal_node_id, false)];
+	let mut metered_blocks_iter = blocks.iter().peekable();
+
+	let locals_count = body
+		.locals()
+		.iter()
+		.try_fold(0u32, |count, val_type| count.checked_add(val_type.count()))
+		.ok_or(())?;
+	let locals_init_cost = rules.call_per_local_cost().checked_mul(locals_count).ok_or(())?;
+
+	for (cursor, instruction) in body.code().elements().iter().enumerate() {
+		let active_node_id = stack
+			.last()
+			.expect("module is valid by pre-condition; control stack must not be empty; qed")
+			.active_node;
+
+		// Increment the charged cost if there are metering instructions to be inserted here.
+		let apply_block =
+			metered_blocks_iter.peek().map_or(false, |block| block.start_pos == cursor);
+		if apply_block {
+			let next_metered_block =
+				metered_blocks_iter.next().expect("peek returned an item; qed");
+			graph.increment_charged_cost(active_node_id, next_metered_block.cost);
+		}
+
+		// Add locals initialization cost to the function block.
+		if cursor == 0 {
+			graph.increment_actual_cost(active_node_id, locals_init_cost);
+		}
+		let instruction_cost = rules.instruction_cost(instruction).ok_or(())?;
+		match instruction {
+			Instruction::Block(_) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let exit_node_id = graph.add_node();
+				stack.push(ControlFrame::new(active_node_id, exit_node_id, false));
+			},
+			Instruction::If(_) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let then_node_id = graph.add_node();
+				let exit_node_id = graph.add_node();
+
+				stack.push(ControlFrame::new(then_node_id, exit_node_id, false));
+				graph.new_forward_edge(active_node_id, then_node_id);
+				graph.set_first_instr_pos(then_node_id, cursor + 1);
+			},
+			Instruction::Loop(_) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let loop_node_id = graph.add_node();
+				let exit_node_id = graph.add_node();
+
+				stack.push(ControlFrame::new(loop_node_id, exit_node_id, true));
+				graph.new_forward_edge(active_node_id, loop_node_id);
+				graph.set_first_instr_pos(loop_node_id, cursor + 1);
+			},
+			Instruction::Else => {
+				let active_frame_idx = stack.len() - 1;
+				let prev_frame_idx = stack.len() - 2;
+
+				let else_node_id = graph.add_node();
+				stack[active_frame_idx].active_node = else_node_id;
+
+				let prev_node_id = stack[prev_frame_idx].active_node;
+				graph.new_forward_edge(prev_node_id, else_node_id);
+				graph.set_first_instr_pos(else_node_id, cursor + 1);
+			},
+			Instruction::End => {
+				let closing_frame = stack.pop()
+					.expect("module is valid by pre-condition; ends correspond to control stack frames; qed");
+
+				graph.new_forward_edge(active_node_id, closing_frame.exit_node);
+				graph.set_first_instr_pos(closing_frame.exit_node, cursor + 1);
+
+				if let Some(active_frame) = stack.last_mut() {
+					active_frame.active_node = closing_frame.exit_node;
+				}
+			},
+			Instruction::Br(label) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let active_frame_idx = stack.len() - 1;
+				let target_frame_idx = active_frame_idx - (*label as usize);
+				graph.new_edge(active_node_id, &stack[target_frame_idx]);
+
+				// Next instruction is unreachable, but carry on anyway.
+				let new_node_id = graph.add_node();
+				stack[active_frame_idx].active_node = new_node_id;
+				graph.set_first_instr_pos(new_node_id, cursor + 1);
+			},
+			Instruction::BrIf(label) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let active_frame_idx = stack.len() - 1;
+				let target_frame_idx = active_frame_idx - (*label as usize);
+				graph.new_edge(active_node_id, &stack[target_frame_idx]);
+
+				let new_node_id = graph.add_node();
+				stack[active_frame_idx].active_node = new_node_id;
+				graph.new_forward_edge(active_node_id, new_node_id);
+				graph.set_first_instr_pos(new_node_id, cursor + 1);
+			},
+			Instruction::BrTable(br_table_data) => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				let active_frame_idx = stack.len() - 1;
+				for &label in [br_table_data.default].iter().chain(br_table_data.table.iter()) {
+					let target_frame_idx = active_frame_idx - (label as usize);
+					graph.new_edge(active_node_id, &stack[target_frame_idx]);
+				}
+
+				let new_node_id = graph.add_node();
+				stack[active_frame_idx].active_node = new_node_id;
+				graph.set_first_instr_pos(new_node_id, cursor + 1);
+			},
+			Instruction::Return => {
+				graph.increment_actual_cost(active_node_id, instruction_cost);
+
+				graph.new_forward_edge(active_node_id, terminal_node_id);
+
+				let active_frame_idx = stack.len() - 1;
+				let new_node_id = graph.add_node();
+				stack[active_frame_idx].active_node = new_node_id;
+				graph.set_first_instr_pos(new_node_id, cursor + 1);
+			},
+			_ => graph.increment_actual_cost(active_node_id, instruction_cost),
+		}
+	}
+
+	assert!(stack.is_empty());
+
+	Ok(graph)
+}
+
+/// Exhaustively search through all paths in the control flow graph, starting from the first node
+/// and ensure that 1) all paths with only forward edges ending with the terminal node have an
+/// equal total actual gas cost and total charged gas cost, and 2) all cycles beginning with a loop
+/// entry point and ending with a node with a loop-back edge to the entry point have equal actual
+/// and charged gas costs. If this returns true, then the metered blocks used to construct the
+/// control flow graph are correct with respect to the function body.
+///
+/// In the worst case, this runs in time exponential in the size of the graph.
+fn validate_graph_gas_costs(graph: &ControlFlowGraph) -> bool {
+	fn visit(
+		graph: &ControlFlowGraph,
+		node_id: NodeId,
+		mut total_actual: u64,
+		mut total_charged: u64,
+		loop_costs: &mut Map<NodeId, (u64, u64)>,
+	) -> bool {
+		let node = graph.get_node(node_id);
+
+		total_actual += node.actual_cost;
+		total_charged += node.charged_cost;
+
+		if node.is_loop_target {
+			loop_costs.insert(node_id, (node.actual_cost, node.charged_cost));
+		}
+
+		if node.forward_edges.is_empty() && total_actual != total_charged {
+			return false
+		}
+
+		for loop_node_id in node.loopback_edges.iter() {
+			let (loop_actual, loop_charged) = loop_costs
+				.get_mut(loop_node_id)
+				.expect("cannot arrive at loopback edge without visiting loop entry node");
+			if loop_actual != loop_charged {
+				return false
+			}
+		}
+
+		for next_node_id in node.forward_edges.iter() {
+			if !visit(graph, *next_node_id, total_actual, total_charged, loop_costs) {
+				return false
+			}
+		}
+
+		if node.is_loop_target {
+			loop_costs.remove(&node_id);
+		}
+
+		true
+	}
+
+	// Recursively explore all paths through the execution graph starting from the entry node.
+	visit(graph, 0, 0, 0, &mut Map::new())
+}
+
+/// Validate that the metered blocks are correct with respect to the function body by exhaustively
+/// searching all paths through the control flow graph.
+///
+/// This assumes that the function body has been validated already, otherwise this may panic.
+fn validate_metering_injections(
+	body: &FuncBody,
+	rules: &impl Rules,
+	blocks: &[MeteredBlock],
+) -> Result<bool, ()> {
+	let graph = build_control_flow_graph(body, rules, blocks)?;
+	Ok(validate_graph_gas_costs(&graph))
+}
+
+mod tests {
+	use super::{super::determine_metered_blocks, *};
+
+	use binaryen::tools::translate_to_fuzz_mvp;
+	use parity_wasm::elements;
+	use rand::{thread_rng, RngCore};
+
+	#[test]
+	fn test_build_control_flow_graph() {
+		for _ in 0..20 {
+			let mut rand_input = [0u8; 2048];
+			thread_rng().fill_bytes(&mut rand_input);
+
+			let module_bytes = translate_to_fuzz_mvp(&rand_input).write();
+			let module: elements::Module = elements::deserialize_buffer(&module_bytes)
+				.expect("failed to parse Wasm blob generated by translate_to_fuzz");
+
+			for func_body in module.code_section().iter().flat_map(|section| section.bodies()) {
+				let rules = ConstantCostRules::default();
+				let locals_count = func_body.locals().iter().map(|val_type| val_type.count()).sum();
+
+				let metered_blocks =
+					determine_metered_blocks(func_body.code(), &rules, locals_count).unwrap();
+				let success =
+					validate_metering_injections(func_body, &rules, &metered_blocks).unwrap();
+				assert!(success);
+			}
+		}
+	}
+}

src/lib.rs

@@ -1,41 +1,11 @@
 #![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(not(feature = "std"), feature(alloc))]
 
-#[cfg(not(feature = "std"))]
-#[macro_use]
 extern crate alloc;
 
-extern crate parity_wasm;
-extern crate byteorder;
-#[macro_use] extern crate log;
+mod export_globals;
+pub mod gas_metering;
+mod stack_limiter;
 
-pub static CREATE_SYMBOL: &'static str = "deploy";
-pub static CALL_SYMBOL: &'static str = "call";
-pub static RET_SYMBOL: &'static str = "ret";
-
-pub mod rules;
-
-mod optimizer;
-mod gas;
-mod symbols;
-mod ext;
-mod pack;
-mod runtime_type;
-
-pub mod stack_height;
-
-pub use optimizer::{optimize, Error as OptimizerError};
-pub use gas::inject_gas_counter;
-pub use ext::{externalize, externalize_mem, underscore_funcs, ununderscore_funcs, shrink_unknown_stack};
-pub use pack::{pack_instance, Error as PackingError};
-pub use runtime_type::inject_runtime_type;
-
-#[cfg(not(feature = "std"))]
-mod std {
-	pub use core::*;
-	pub use alloc::{vec, string, boxed, borrow};
-
-	pub mod collections {
-		pub use alloc::{BTreeMap, BTreeSet};
-	}
-}
+pub use export_globals::export_mutable_globals;
+pub use parity_wasm;
+pub use stack_limiter::inject as inject_stack_limiter;

src/optimizer.rs

@@ -1,623 +0,0 @@
-#[cfg(features = "std")]
-use std::collections::{HashSet as Set};
-#[cfg(not(features = "std"))]
-use std::collections::{BTreeSet as Set};
-use std::vec::Vec;
-
-use parity_wasm::elements;
-
-use symbols::{Symbol, expand_symbols, push_code_symbols, resolve_function};
-
-#[derive(Debug)]
-pub enum Error {
-	/// Since optimizer starts with export entries, export
-	///   section is supposed to exist.
-	NoExportSection,
-}
-
-pub fn optimize(
-	module: &mut elements::Module, // Module to optimize
-	used_exports: Vec<&str>,       // List of only exports that will be usable after optimization
-) -> Result<(), Error> {
-	// WebAssembly exports optimizer
-	// Motivation: emscripten compiler backend compiles in many unused exports
-	//   which in turn compile in unused imports and leaves unused functions
-
-	// Algo starts from the top, listing all items that should stay
-	let mut stay = Set::new();
-	for (index, entry) in module.export_section().ok_or(Error::NoExportSection)?.entries().iter().enumerate() {
-		if used_exports.iter().find(|e| **e == entry.field()).is_some() {
-			stay.insert(Symbol::Export(index));
-		}
-	}
-
-	// If there is start function in module, it should stary
-	module.start_section().map(|ss| stay.insert(resolve_function(&module, ss)));
-
-	// All symbols used in data/element segments are also should be preserved
-	let mut init_symbols = Vec::new();
-	if let Some(data_section) = module.data_section() {
-		for segment in data_section.entries() {
-			push_code_symbols(&module, segment.offset().code(), &mut init_symbols);
-		}
-	}
-	if let Some(elements_section) = module.elements_section() {
-		for segment in elements_section.entries() {
-			push_code_symbols(&module, segment.offset().code(), &mut init_symbols);
-			for func_index in segment.members() {
-				stay.insert(resolve_function(&module, *func_index));
-			}
-		}
-	}
-	for symbol in init_symbols.drain(..) { stay.insert(symbol); }
-
-	// Call function which will traverse the list recursively, filling stay with all symbols
-	// that are already used by those which already there
-	expand_symbols(module, &mut stay);
-
-	for symbol in stay.iter() {
-		trace!("symbol to stay: {:?}", symbol);
-	}
-
-	// Keep track of referreable symbols to rewire calls/globals
-	let mut eliminated_funcs = Vec::new();
-	let mut eliminated_globals = Vec::new();
-	let mut eliminated_types = Vec::new();
-
-	// First, iterate through types
-	let mut index = 0;
-	let mut old_index = 0;
-
-	{
-		loop {
-			if type_section(module).map(|section| section.types_mut().len()).unwrap_or(0) == index { break; }
-
-			if stay.contains(&Symbol::Type(old_index)) {
-				index += 1;
-			} else {
-				type_section(module)
-					.expect("If type section does not exists, the loop will break at the beginning of first iteration")
-					.types_mut().remove(index);
-				eliminated_types.push(old_index);
-				trace!("Eliminated type({})", old_index);
-			}
-			old_index += 1;
-		}
-	}
-
-	// Second, iterate through imports
-	let mut top_funcs = 0;
-	let mut top_globals = 0;
-	index = 0;
-	old_index = 0;
-
-	if let Some(imports) = import_section(module) {
-		loop {
-			let mut remove = false;
-			match imports.entries()[index].external() {
-				&elements::External::Function(_) => {
-					if stay.contains(&Symbol::Import(old_index)) {
-						index += 1;
-					} else {
-						remove = true;
-						eliminated_funcs.push(top_funcs);
-						trace!("Eliminated import({}) func({}, {})", old_index, top_funcs, imports.entries()[index].field());
-					}
-					top_funcs += 1;
-				},
-				&elements::External::Global(_) => {
-					if stay.contains(&Symbol::Import(old_index)) {
-						index += 1;
-					} else {
-						remove = true;
-						eliminated_globals.push(top_globals);
-						trace!("Eliminated import({}) global({}, {})", old_index, top_globals, imports.entries()[index].field());
-					}
-					top_globals += 1;
-				},
-				_ => {
-					index += 1;
-				}
-			}
-			if remove {
-				imports.entries_mut().remove(index);
-			}
-
-			old_index += 1;
-
-			if index == imports.entries().len() { break; }
-		}
-	}
-
-	// Third, iterate through globals
-	if let Some(globals) = global_section(module) {
-		index = 0;
-		old_index = 0;
-
-		loop {
-			if globals.entries_mut().len() == index { break; }
-			if stay.contains(&Symbol::Global(old_index)) {
-				index += 1;
-			} else {
-				globals.entries_mut().remove(index);
-				eliminated_globals.push(top_globals + old_index);
-				trace!("Eliminated global({})", top_globals + old_index);
-			}
-			old_index += 1;
-		}
-	}
-
-	// Forth, delete orphaned functions
-	if function_section(module).is_some() && code_section(module).is_some() {
-		index = 0;
-		old_index = 0;
-
-		loop {
-			if function_section(module).expect("Functons section to exist").entries_mut().len() == index { break; }
-			if stay.contains(&Symbol::Function(old_index)) {
-				index += 1;
-			} else {
-				function_section(module).expect("Functons section to exist").entries_mut().remove(index);
-				code_section(module).expect("Code section to exist").bodies_mut().remove(index);
-
-				eliminated_funcs.push(top_funcs + old_index);
-				trace!("Eliminated function({})", top_funcs + old_index);
-			}
-			old_index += 1;
-		}
-	}
-
-	// Fifth, eliminate unused exports
-	{
-		let exports = export_section(module).ok_or(Error::NoExportSection)?;
-
-		index = 0;
-		old_index = 0;
-
-		loop {
-			if exports.entries_mut().len() == index { break; }
-			if stay.contains(&Symbol::Export(old_index)) {
-				index += 1;
-			} else {
-				trace!("Eliminated export({}, {})", old_index, exports.entries_mut()[index].field());
-				exports.entries_mut().remove(index);
-			}
-			old_index += 1;
-		}
-	}
-
-	if eliminated_globals.len() > 0 || eliminated_funcs.len() > 0 || eliminated_types.len() > 0 {
-		// Finaly, rewire all calls, globals references and types to the new indices
-		//   (only if there is anything to do)
-		eliminated_globals.sort();
-		eliminated_funcs.sort();
-		eliminated_types.sort();
-
-		for section in module.sections_mut() {
-			match section {
-				&mut elements::Section::Start(ref mut func_index) if eliminated_funcs.len() > 0 => {
-					let totalle = eliminated_funcs.iter().take_while(|i| (**i as u32) < *func_index).count();
-					*func_index -= totalle as u32;
-				},
-				&mut elements::Section::Function(ref mut function_section) if eliminated_types.len() > 0 => {
-					for ref mut func_signature in function_section.entries_mut() {
-						let totalle = eliminated_types.iter().take_while(|i| (**i as u32) < func_signature.type_ref()).count();
-						*func_signature.type_ref_mut() -= totalle as u32;
-					}
-				},
-				&mut elements::Section::Import(ref mut import_section) if eliminated_types.len() > 0 => {
-					for ref mut import_entry in import_section.entries_mut() {
-						if let &mut elements::External::Function(ref mut type_ref) = import_entry.external_mut() {
-							let totalle = eliminated_types.iter().take_while(|i| (**i as u32) < *type_ref).count();
-							*type_ref -= totalle as u32;
-						}
-					}
-				},
-				&mut elements::Section::Code(ref mut code_section) if eliminated_globals.len() > 0 || eliminated_funcs.len() > 0 => {
-					for ref mut func_body in code_section.bodies_mut() {
-						if eliminated_funcs.len() > 0 {
-							update_call_index(func_body.code_mut(), &eliminated_funcs);
-						}
-						if eliminated_globals.len() > 0 {
-							update_global_index(func_body.code_mut().elements_mut(), &eliminated_globals)
-						}
-						if eliminated_types.len() > 0 {
-							update_type_index(func_body.code_mut(), &eliminated_types)
-						}
-					}
-				},
-				&mut elements::Section::Export(ref mut export_section) => {
-					for ref mut export in export_section.entries_mut() {
-						match export.internal_mut() {
-							&mut elements::Internal::Function(ref mut func_index) => {
-								let totalle = eliminated_funcs.iter().take_while(|i| (**i as u32) < *func_index).count();
-								*func_index -= totalle as u32;
-							},
-							&mut elements::Internal::Global(ref mut global_index) => {
-								let totalle = eliminated_globals.iter().take_while(|i| (**i as u32) < *global_index).count();
-								*global_index -= totalle as u32;
-							},
-							_ => {}
-						}
-					}
-				},
-				&mut elements::Section::Global(ref mut global_section) => {
-					for ref mut global_entry in global_section.entries_mut() {
-						update_global_index(global_entry.init_expr_mut().code_mut(), &eliminated_globals)
-					}
-				},
-				&mut elements::Section::Data(ref mut data_section) => {
-					for ref mut segment in data_section.entries_mut() {
-						update_global_index(segment.offset_mut().code_mut(), &eliminated_globals)
-					}
-				},
-				&mut elements::Section::Element(ref mut elements_section) => {
-					for ref mut segment in elements_section.entries_mut() {
-						update_global_index(segment.offset_mut().code_mut(), &eliminated_globals);
-						// update all indirect call addresses initial values
-						for func_index in segment.members_mut() {
-							let totalle = eliminated_funcs.iter().take_while(|i| (**i as u32) < *func_index).count();
-							*func_index -= totalle as u32;
-						}
-					}
-				},
-				_ => { }
-			}
-		}
-	}
-
-	Ok(())
-}
-
-
-pub fn update_call_index(opcodes: &mut elements::Opcodes, eliminated_indices: &[usize]) {
-	use parity_wasm::elements::Opcode::*;
-	for opcode in opcodes.elements_mut().iter_mut() {
-		match opcode {
-			&mut Call(ref mut call_index) => {
-				let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *call_index).count();
-				trace!("rewired call {} -> call {}", *call_index, *call_index - totalle as u32);
-				*call_index -= totalle as u32;
-			},
-			_ => { },
-		}
-	}
-}
-
-/// Updates global references considering the _ordered_ list of eliminated indices
-pub fn update_global_index(opcodes: &mut Vec<elements::Opcode>, eliminated_indices: &[usize]) {
-	use parity_wasm::elements::Opcode::*;
-	for opcode in opcodes.iter_mut() {
-		match opcode {
-			&mut GetGlobal(ref mut index) | &mut SetGlobal(ref mut index) => {
-				let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *index).count();
-				trace!("rewired global {} -> global {}", *index, *index - totalle as u32);
-				*index -= totalle as u32;
-			},
-			_ => { },
-		}
-	}
-}
-
-/// Updates global references considering the _ordered_ list of eliminated indices
-pub fn update_type_index(opcodes: &mut elements::Opcodes, eliminated_indices: &[usize]) {
-	use parity_wasm::elements::Opcode::*;
-	for opcode in opcodes.elements_mut().iter_mut() {
-		match opcode {
-			&mut CallIndirect(ref mut call_index, _) => {
-				let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *call_index).count();
-				trace!("rewired call_indrect {} -> call_indirect {}", *call_index, *call_index - totalle as u32);
-				*call_index -= totalle as u32;
-			},
-			_ => { },
-		}
-	}
-}
-
-pub fn import_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::ImportSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Import(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn global_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::GlobalSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Global(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn function_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::FunctionSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Function(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn code_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::CodeSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Code(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn export_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::ExportSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Export(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-pub fn type_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::TypeSection> {
-   for section in module.sections_mut() {
-		match section {
-			&mut elements::Section::Type(ref mut sect) => {
-				return Some(sect);
-			},
-			_ => { }
-		}
-	}
-	None
-}
-
-#[cfg(test)]
-mod tests {
-
-	use parity_wasm::{builder, elements};
-	use super::*;
-
-	/// @spec 0
-	/// Optimizer presumes that export section exists and contains
-	/// all symbols passed as a second parameter. Since empty module
-	/// obviously contains no export section, optimizer should return
-	/// error on it.
-	#[test]
-	fn empty() {
-		let mut module = builder::module().build();
-		let result = optimize(&mut module, vec!["_call"]);
-
-		assert!(result.is_err());
-	}
-
-	/// @spec 1
-	/// Imagine the unoptimized module has two own functions, `_call` and `_random`
-	/// and exports both of them in the export section. During optimization, the `_random`
-	/// function should vanish completely, given we pass `_call` as the only function to stay
-	/// in the module.
-	#[test]
-	fn minimal() {
-		let mut module = builder::module()
-			.function()
-				.signature().param().i32().build()
-				.build()
-			.function()
-				.signature()
-					.param().i32()
-					.param().i32()
-					.build()
-				.build()
-			.export()
-				.field("_call")
-				.internal().func(0).build()
-			.export()
-				.field("_random")
-				.internal().func(1).build()
-			.build();
-		assert_eq!(module.export_section().expect("export section to be generated").entries().len(), 2);
-
-		optimize(&mut module, vec!["_call"]).expect("optimizer to succeed");
-
-		assert_eq!(
-			1,
-			module.export_section().expect("export section to be generated").entries().len(),
-			"There should only 1 (one) export entry in the optimized module"
-		);
-
-		assert_eq!(
-			1,
-			module.function_section().expect("functions section to be generated").entries().len(),
-			"There should 2 (two) functions in the optimized module"
-		);
-	}
-
-	/// @spec 2
-	/// Imagine there is one exported function in unoptimized module, `_call`, that we specify as the one
-	/// to stay during the optimization. The code of this function uses global during the execution.
-	/// This sayed global should survive the optimization.
-	#[test]
-	fn globals() {
-		let mut module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							elements::Opcode::GetGlobal(0),
-							elements::Opcode::End
-						]
-					))
-					.build()
-				.build()
-			.export()
-				.field("_call")
-				.internal().func(0).build()
-			.build();
-
-		optimize(&mut module, vec!["_call"]).expect("optimizer to succeed");
-
-		assert_eq!(
-			1,
-			module.global_section().expect("global section to be generated").entries().len(),
-			"There should 1 (one) global entry in the optimized module, since _call function uses it"
-		);
-	}
-
-	/// @spec 2
-	/// Imagine there is one exported function in unoptimized module, `_call`, that we specify as the one
-	/// to stay during the optimization. The code of this function uses one global during the execution,
-	/// but we have a bunch of other unused globals in the code. Last globals should not survive the optimization,
-	/// while the former should.
-	#[test]
-	fn globals_2() {
-		let mut module = builder::module()
-			.global()
-				.value_type().i32()
-				.build()
-			.global()
-				.value_type().i64()
-				.build()
-			.global()
-				.value_type().f32()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							elements::Opcode::GetGlobal(1),
-							elements::Opcode::End
-						]
-					))
-					.build()
-				.build()
-			.export()
-				.field("_call")
-				.internal().func(0).build()
-			.build();
-
-		optimize(&mut module, vec!["_call"]).expect("optimizer to succeed");
-
-		assert_eq!(
-			1,
-			module.global_section().expect("global section to be generated").entries().len(),
-			"There should 1 (one) global entry in the optimized module, since _call function uses only one"
-		);
-	}
-
-	/// @spec 3
-	/// Imagine the unoptimized module has two own functions, `_call` and `_random`
-	/// and exports both of them in the export section. Function `_call` also calls `_random`
-	/// in its function body. The optimization should kick `_random` function from the export section
-	/// but preserve it's body.
-	#[test]
-	fn call_ref() {
-		let mut module = builder::module()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							elements::Opcode::Call(1),
-							elements::Opcode::End
-						]
-					))
-					.build()
-				.build()
-			.function()
-				.signature()
-					.param().i32()
-					.param().i32()
-					.build()
-				.build()
-			.export()
-				.field("_call")
-				.internal().func(0).build()
-			.export()
-				.field("_random")
-				.internal().func(1).build()
-			.build();
-		assert_eq!(module.export_section().expect("export section to be generated").entries().len(), 2);
-
-		optimize(&mut module, vec!["_call"]).expect("optimizer to succeed");
-
-		assert_eq!(
-			1,
-			module.export_section().expect("export section to be generated").entries().len(),
-			"There should only 1 (one) export entry in the optimized module"
-		);
-
-		assert_eq!(
-			2,
-			module.function_section().expect("functions section to be generated").entries().len(),
-			"There should 2 (two) functions in the optimized module"
-		);
-	}
-
-	/// @spec 4
-	/// Imagine the unoptimized module has an indirect call to function of type 1
-	/// The type should persist so that indirect call would work
-	#[test]
-	fn call_indirect() {
-		let mut module = builder::module()
-			.function()
-				.signature().param().i32().param().i32().build()
-				.build()
-			.function()
-				.signature().param().i32().param().i32().build()
-				.build()
-			.function()
-				.signature().param().i32().build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						vec![
-							elements::Opcode::CallIndirect(1, 0),
-							elements::Opcode::End
-						]
-					))
-					.build()
-				.build()
-			.export()
-				.field("_call")
-				.internal().func(2).build()
-			.build();
-
-		optimize(&mut module, vec!["_call"]).expect("optimizer to succeed");
-
-		assert_eq!(
-			2,
-			module.type_section().expect("type section to be generated").types().len(),
-			"There should 2 (two) types left in the module, 1 for indirect call and one for _call"
-		);
-
-		let indirect_opcode = &module.code_section().expect("code section to be generated").bodies()[0].code().elements()[0];
-		match *indirect_opcode {
-			elements::Opcode::CallIndirect(0, 0) => {},
-			_ => {
-				panic!(
-					"Expected call_indirect to use index 0 after optimization, since previois 0th was eliminated, but got {:?}",
-					indirect_opcode
-				);
-			}
-		}
-	}
-
-}

src/pack.rs

@@ -1,338 +0,0 @@
-use std::fmt;
-use std::vec::Vec;
-use std::borrow::ToOwned;
-
-use parity_wasm::elements::{
-    self, Section, DataSection, Opcode, DataSegment, InitExpr, Internal, External,
-    ImportCountType,
-};
-use parity_wasm::builder;
-use super::{CREATE_SYMBOL, CALL_SYMBOL, RET_SYMBOL};
-use super::gas::update_call_index;
-
-/// Pack error.
-///
-/// Pack has number of assumptions of passed module structure.
-/// When they are violated, pack_instance returns one of these.
-#[derive(Debug)]
-pub enum Error {
-    MalformedModule,
-    NoTypeSection,
-    NoExportSection,
-    NoCodeSection,
-    InvalidCreateSignature,
-    NoCreateSymbol,
-    InvalidCreateMember,
-    NoImportSection,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        match *self {
-            Error::MalformedModule => write!(f, "Module internal references are inconsistent"),
-            Error::NoTypeSection => write!(f, "No type section in the module"),
-            Error::NoExportSection => write!(f, "No export section in the module"),
-            Error::NoCodeSection => write!(f, "No code section inthe module"),
-            Error::InvalidCreateSignature => write!(f, "Exported symbol `deploy` has invalid signature, should be () -> ()"),
-            Error::InvalidCreateMember => write!(f, "Exported symbol `deploy` should be a function"),
-            Error::NoCreateSymbol => write!(f, "No exported `deploy` symbol"),
-            Error::NoImportSection => write!(f, "No import section in the module"),
-        }
-    }
-}
-
-/// If module has an exported "_create" function we want to pack it into "constructor".
-/// `raw_module` is the actual contract code
-/// `ctor_module` is the constructor which should return `raw_module`
-pub fn pack_instance(raw_module: Vec<u8>, mut ctor_module: elements::Module) -> Result<elements::Module, Error> {
-
-    // Total number of constructor module import functions
-    let ctor_import_functions = ctor_module.import_section().map(|x| x.functions()).unwrap_or(0);
-
-    // We need to find an internal ID of function witch is exported as "_create"
-    // in order to find it in the Code section of the module
-    let mut create_func_id = {
-        let found_entry = ctor_module.export_section().ok_or(Error::NoExportSection)?.entries().iter()
-            .find(|entry| CREATE_SYMBOL == entry.field()).ok_or(Error::NoCreateSymbol)?;
-
-        let function_index: usize = match found_entry.internal() {
-            &Internal::Function(index) => index as usize,
-            _ => { return Err(Error::InvalidCreateMember) },
-        };
-
-        // Calculates a function index within module's function section
-        let function_internal_index = function_index - ctor_import_functions;
-
-        // Constructor should be of signature `func(i32)` (void), fail otherwise
-        let type_id = ctor_module.function_section().ok_or(Error::NoCodeSection)?
-            .entries().get(function_index - ctor_import_functions).ok_or(Error::MalformedModule)?
-            .type_ref();
-
-        let &elements::Type::Function(ref func) = ctor_module.type_section().ok_or(Error::NoTypeSection)?
-            .types().get(type_id as usize).ok_or(Error::MalformedModule)?;
-
-        // Deploy should have no arguments and also should return nothing
-        if !func.params().is_empty() {
-            return Err(Error::InvalidCreateSignature);
-        }
-        if func.return_type().is_some() {
-            return Err(Error::InvalidCreateSignature);
-        }
-
-        function_internal_index
-    };
-
-    let ret_function_id = {
-        let mut id = 0;
-        let mut found = false;
-        for entry in ctor_module.import_section().ok_or(Error::NoImportSection)?.entries().iter() {
-            if let External::Function(_) = *entry.external() {
-                if entry.field() == RET_SYMBOL { found = true; break; }
-                else { id += 1; }
-            }
-        }
-        if !found {
-            let mut mbuilder = builder::from_module(ctor_module);
-            let import_sig = mbuilder.push_signature(
-                builder::signature()
-                    .param().i32().param().i32()
-                    .build_sig()
-                );
-
-            mbuilder.push_import(
-                builder::import()
-                    .module("env")
-                    .field("ret")
-                    .external().func(import_sig)
-                    .build()
-                );
-
-            ctor_module = mbuilder.build();
-
-            let ret_func = ctor_module.import_count(ImportCountType::Function) as u32 - 1;
-
-            for section in ctor_module.sections_mut() {
-                match *section {
-                    elements::Section::Code(ref mut code_section) => {
-                        for ref mut func_body in code_section.bodies_mut() {
-                            update_call_index(func_body.code_mut(), ret_func);
-                        }
-                    },
-                    elements::Section::Export(ref mut export_section) => {
-                        for ref mut export in export_section.entries_mut() {
-                            match export.internal_mut() {
-                                &mut elements::Internal::Function(ref mut func_index) => {
-                                    if *func_index >= ret_func { *func_index += 1}
-                                },
-                                _ => {}
-                            }
-                        }
-                    },
-                    elements::Section::Element(ref mut elements_section) => {
-                        for ref mut segment in elements_section.entries_mut() {
-                            // update all indirect call addresses initial values
-                            for func_index in segment.members_mut() {
-                                if *func_index >= ret_func { *func_index += 1}
-                            }
-                        }
-                    },
-                    _ => { }
-                }
-            }
-
-            create_func_id += 1;
-            ret_func
-         }
-        else { id }
-    };
-
-    // If new function is put in ctor module, it will have this callable index
-    let last_function_index = ctor_module.functions_space();
-
-    // We ensure here that module has the DataSection
-    if ctor_module
-        .sections()
-        .iter()
-        .find(|section| match **section { Section::Data(ref _d) => true, _ => false })
-        .is_none() {
-        // DataSection has to be the last non-custom section according the to the spec
-        ctor_module.sections_mut().push(Section::Data(DataSection::with_entries(vec![])));
-    }
-
-    // Code data address is an address where we put the contract's code (raw_module)
-    let mut code_data_address = 0i32;
-
-    for section in ctor_module.sections_mut() {
-        match section {
-            &mut Section::Data(ref mut data_section) => {
-                let (index, offset) = if let Some(ref entry) = data_section.entries().iter().last() {
-                    if let Opcode::I32Const(offst) = entry.offset().code()[0] {
-                        let len = entry.value().len() as i32;
-                        let offst = offst as i32;
-                        (entry.index(), offst + (len + 4) - len % 4)
-                    } else {
-                        (0, 0)
-                    }
-                } else {
-                    (0, 0)
-                };
-                let code_data = DataSegment::new(
-                    index,
-                    InitExpr::new(vec![Opcode::I32Const(offset), Opcode::End]),
-                    raw_module.clone()
-                );
-                data_section.entries_mut().push(code_data);
-                code_data_address = offset;
-            },
-            _ => {;}
-        }
-    }
-
-    let mut new_module = builder::from_module(ctor_module)
-        .function()
-        .signature().build()
-        .body().with_opcodes(elements::Opcodes::new(
-            vec![
-                Opcode::Call((create_func_id + ctor_import_functions) as u32),
-                Opcode::I32Const(code_data_address),
-                Opcode::I32Const(raw_module.len() as i32),
-                Opcode::Call(ret_function_id as u32),
-                Opcode::End,
-            ])).build()
-            .build()
-        .build();
-
-    for section in new_module.sections_mut() {
-        match section {
-            &mut Section::Export(ref mut export_section) => {
-                for entry in export_section.entries_mut().iter_mut() {
-                    if CREATE_SYMBOL == entry.field() {
-                        // change _create export name into default _call
-                        *entry.field_mut() = CALL_SYMBOL.to_owned();
-                        *entry.internal_mut() = elements::Internal::Function(last_function_index as u32);
-                    }
-                }
-            },
-            _ => { },
-        }
-    };
-
-    Ok(new_module)
-}
-
-#[cfg(test)]
-mod test {
-    extern crate parity_wasm;
-
-    use parity_wasm::builder;
-    use super::*;
-    use super::super::optimize;
-
-    fn test_packer(mut module: elements::Module) {
-        let mut ctor_module = module.clone();
-        optimize(&mut module, vec![CALL_SYMBOL]).expect("Optimizer to finish without errors");
-        optimize(&mut ctor_module, vec![CREATE_SYMBOL]).expect("Optimizer to finish without errors");
-
-        let raw_module = parity_wasm::serialize(module).unwrap();
-        let ctor_module = pack_instance(raw_module.clone(), ctor_module).expect("Packing failed");
-
-        let data_section = ctor_module.data_section().expect("Packed module has to have a data section");
-        let data_segment = data_section.entries().iter().last().expect("Packed module has to have a data section with at least one entry");
-        assert!(data_segment.value() == AsRef::<[u8]>::as_ref(&raw_module), "Last data segment should be equal to the raw module");
-    }
-
-    #[test]
-    fn no_data_section() {
-        test_packer(builder::module()
-            .import()
-                .module("env")
-                .field("memory")
-                .external().memory(1 as u32, Some(1 as u32))
-                .build()
-            .function()
-                .signature()
-                    .params().i32().i32().build()
-                        .build()
-                    .body().build()
-                    .build()
-            .function()
-                .signature().build()
-                .body()
-                    .with_opcodes(elements::Opcodes::new(
-                        vec![
-                            elements::Opcode::End
-                        ]
-                    ))
-                    .build()
-            .build()
-            .function()
-                .signature().build()
-                .body()
-                    .with_opcodes(elements::Opcodes::new(
-                        vec![
-                            elements::Opcode::End
-                        ]
-                    ))
-                    .build()
-            .build()
-            .export()
-                .field(CALL_SYMBOL)
-                .internal().func(1)
-            .build()
-            .export()
-                .field(CREATE_SYMBOL)
-                .internal().func(2)
-            .build()
-        .build()
-        );
-    }
-
-    #[test]
-    fn with_data_section() {
-        test_packer(builder::module()
-            .import()
-                .module("env")
-                .field("memory")
-                .external().memory(1 as u32, Some(1 as u32))
-                .build()
-            .data()
-                .offset(elements::Opcode::I32Const(16)).value(vec![0u8])
-                .build()
-            .function()
-                .signature()
-                    .params().i32().i32().build()
-                        .build()
-                    .body().build()
-                    .build()
-            .function()
-                .signature().build()
-                .body()
-                    .with_opcodes(elements::Opcodes::new(
-                        vec![
-                            elements::Opcode::End
-                        ]
-                    ))
-                    .build()
-            .build()
-            .function()
-                .signature().build()
-                .body()
-                    .with_opcodes(elements::Opcodes::new(
-                        vec![
-                            elements::Opcode::End
-                        ]
-                    ))
-                    .build()
-            .build()
-            .export()
-                .field(CALL_SYMBOL)
-                .internal().func(1)
-            .build()
-            .export()
-                .field(CREATE_SYMBOL)
-                .internal().func(2)
-            .build()
-        .build()
-        );
-    }
-}

src/rules.rs

@@ -1,315 +0,0 @@
-#[cfg(features = "std")]
-use std::collections::{HashMap as Map};
-#[cfg(not(features = "std"))]
-use std::collections::{BTreeMap as Map};
-
-use parity_wasm::elements;
-
-pub struct UnknownInstruction;
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum Metering {
-    Regular,
-    Forbidden,
-    Fixed(u32),
-}
-
-#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
-pub enum InstructionType {
-    Bit,
-    Add,
-    Mul,
-    Div,
-    Load,
-    Store,
-    Const,
-    FloatConst,
-    Local,
-    Global,
-    ControlFlow,
-    IntegerComparsion,
-    FloatComparsion,
-    Float,
-    Conversion,
-    FloatConversion,
-    Reinterpretation,
-    Unreachable,
-    Nop,
-    CurrentMemory,
-    GrowMemory,
-}
-
-impl ::std::str::FromStr for InstructionType {
-    type Err = UnknownInstruction;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "bit" => Ok(InstructionType::Bit),
-            "add" => Ok(InstructionType::Add),
-            "mul" => Ok(InstructionType::Mul),
-            "div" => Ok(InstructionType::Div),
-            "load" => Ok(InstructionType::Load),
-            "store" => Ok(InstructionType::Store),
-            "const" => Ok(InstructionType::Const),
-            "local" => Ok(InstructionType::Local),
-            "global" => Ok(InstructionType::Global),
-            "flow" => Ok(InstructionType::ControlFlow),
-            "integer_comp" => Ok(InstructionType::IntegerComparsion),
-            "float_comp" => Ok(InstructionType::FloatComparsion),
-            "float" => Ok(InstructionType::Float),
-            "conversion" => Ok(InstructionType::Conversion),
-            "float_conversion" => Ok(InstructionType::FloatConversion),
-            "reinterpret" => Ok(InstructionType::Reinterpretation),
-            "unreachable" => Ok(InstructionType::Unreachable),
-            "nop" => Ok(InstructionType::Nop),
-            "currrent_mem" => Ok(InstructionType::CurrentMemory),
-            "grow_mem" => Ok(InstructionType::GrowMemory),
-            _ => Err(UnknownInstruction),
-        }
-    }
-}
-
-impl InstructionType {
-    pub fn op(opcode: &elements::Opcode) -> Self {
-        use parity_wasm::elements::Opcode::*;
-
-        match *opcode {
-            Unreachable => InstructionType::Unreachable,
-            Nop => InstructionType::Nop,
-            Block(_) => InstructionType::ControlFlow,
-            Loop(_) => InstructionType::ControlFlow,
-            If(_) => InstructionType::ControlFlow,
-            Else => InstructionType::ControlFlow,
-            End => InstructionType::ControlFlow,
-            Br(_) => InstructionType::ControlFlow,
-            BrIf(_) => InstructionType::ControlFlow,
-            BrTable(_, _) => InstructionType::ControlFlow,
-            Return => InstructionType::ControlFlow,
-            Call(_) => InstructionType::ControlFlow,
-            CallIndirect(_, _) => InstructionType::ControlFlow,
-            Drop => InstructionType::ControlFlow,
-            Select => InstructionType::ControlFlow,
-
-            GetLocal(_) => InstructionType::Local,
-            SetLocal(_) => InstructionType::Local,
-            TeeLocal(_) => InstructionType::Local,
-            GetGlobal(_) => InstructionType::Local,
-            SetGlobal(_) => InstructionType::Local,
-
-            I32Load(_, _) => InstructionType::Load,
-            I64Load(_, _) => InstructionType::Load,
-            F32Load(_, _) => InstructionType::Load,
-            F64Load(_, _) => InstructionType::Load,
-            I32Load8S(_, _) => InstructionType::Load,
-            I32Load8U(_, _) => InstructionType::Load,
-            I32Load16S(_, _) => InstructionType::Load,
-            I32Load16U(_, _) => InstructionType::Load,
-            I64Load8S(_, _) => InstructionType::Load,
-            I64Load8U(_, _) => InstructionType::Load,
-            I64Load16S(_, _) => InstructionType::Load,
-            I64Load16U(_, _) => InstructionType::Load,
-            I64Load32S(_, _) => InstructionType::Load,
-            I64Load32U(_, _) => InstructionType::Load,
-
-            I32Store(_, _) => InstructionType::Store,
-            I64Store(_, _) => InstructionType::Store,
-            F32Store(_, _) => InstructionType::Store,
-            F64Store(_, _) => InstructionType::Store,
-            I32Store8(_, _) => InstructionType::Store,
-            I32Store16(_, _) => InstructionType::Store,
-            I64Store8(_, _) => InstructionType::Store,
-            I64Store16(_, _) => InstructionType::Store,
-            I64Store32(_, _) => InstructionType::Store,
-
-            CurrentMemory(_) => InstructionType::CurrentMemory,
-            GrowMemory(_) => InstructionType::GrowMemory,
-
-            I32Const(_) => InstructionType::Const,
-            I64Const(_) => InstructionType::Const,
-
-            F32Const(_) => InstructionType::FloatConst,
-            F64Const(_) => InstructionType::FloatConst,
-
-            I32Eqz => InstructionType::IntegerComparsion,
-            I32Eq => InstructionType::IntegerComparsion,
-            I32Ne => InstructionType::IntegerComparsion,
-            I32LtS => InstructionType::IntegerComparsion,
-            I32LtU => InstructionType::IntegerComparsion,
-            I32GtS => InstructionType::IntegerComparsion,
-            I32GtU => InstructionType::IntegerComparsion,
-            I32LeS => InstructionType::IntegerComparsion,
-            I32LeU => InstructionType::IntegerComparsion,
-            I32GeS => InstructionType::IntegerComparsion,
-            I32GeU => InstructionType::IntegerComparsion,
-
-            I64Eqz => InstructionType::IntegerComparsion,
-            I64Eq => InstructionType::IntegerComparsion,
-            I64Ne => InstructionType::IntegerComparsion,
-            I64LtS => InstructionType::IntegerComparsion,
-            I64LtU => InstructionType::IntegerComparsion,
-            I64GtS => InstructionType::IntegerComparsion,
-            I64GtU => InstructionType::IntegerComparsion,
-            I64LeS => InstructionType::IntegerComparsion,
-            I64LeU => InstructionType::IntegerComparsion,
-            I64GeS => InstructionType::IntegerComparsion,
-            I64GeU => InstructionType::IntegerComparsion,
-
-            F32Eq => InstructionType::FloatComparsion,
-            F32Ne => InstructionType::FloatComparsion,
-            F32Lt => InstructionType::FloatComparsion,
-            F32Gt => InstructionType::FloatComparsion,
-            F32Le => InstructionType::FloatComparsion,
-            F32Ge => InstructionType::FloatComparsion,
-
-            F64Eq => InstructionType::FloatComparsion,
-            F64Ne => InstructionType::FloatComparsion,
-            F64Lt => InstructionType::FloatComparsion,
-            F64Gt => InstructionType::FloatComparsion,
-            F64Le => InstructionType::FloatComparsion,
-            F64Ge => InstructionType::FloatComparsion,
-
-            I32Clz => InstructionType::Bit,
-            I32Ctz => InstructionType::Bit,
-            I32Popcnt => InstructionType::Bit,
-            I32Add => InstructionType::Add,
-            I32Sub => InstructionType::Add,
-            I32Mul => InstructionType::Mul,
-            I32DivS => InstructionType::Div,
-            I32DivU => InstructionType::Div,
-            I32RemS => InstructionType::Div,
-            I32RemU => InstructionType::Div,
-            I32And => InstructionType::Bit,
-            I32Or => InstructionType::Bit,
-            I32Xor => InstructionType::Bit,
-            I32Shl => InstructionType::Bit,
-            I32ShrS => InstructionType::Bit,
-            I32ShrU => InstructionType::Bit,
-            I32Rotl => InstructionType::Bit,
-            I32Rotr => InstructionType::Bit,
-
-            I64Clz => InstructionType::Bit,
-            I64Ctz => InstructionType::Bit,
-            I64Popcnt => InstructionType::Bit,
-            I64Add => InstructionType::Add,
-            I64Sub => InstructionType::Add,
-            I64Mul => InstructionType::Mul,
-            I64DivS => InstructionType::Div,
-            I64DivU => InstructionType::Div,
-            I64RemS => InstructionType::Div,
-            I64RemU => InstructionType::Div,
-            I64And => InstructionType::Bit,
-            I64Or => InstructionType::Bit,
-            I64Xor => InstructionType::Bit,
-            I64Shl => InstructionType::Bit,
-            I64ShrS => InstructionType::Bit,
-            I64ShrU => InstructionType::Bit,
-            I64Rotl => InstructionType::Bit,
-            I64Rotr => InstructionType::Bit,
-
-            F32Abs => InstructionType::Float,
-            F32Neg => InstructionType::Float,
-            F32Ceil => InstructionType::Float,
-            F32Floor => InstructionType::Float,
-            F32Trunc => InstructionType::Float,
-            F32Nearest => InstructionType::Float,
-            F32Sqrt => InstructionType::Float,
-            F32Add => InstructionType::Float,
-            F32Sub => InstructionType::Float,
-            F32Mul => InstructionType::Float,
-            F32Div => InstructionType::Float,
-            F32Min => InstructionType::Float,
-            F32Max => InstructionType::Float,
-            F32Copysign => InstructionType::Float,
-            F64Abs => InstructionType::Float,
-            F64Neg => InstructionType::Float,
-            F64Ceil => InstructionType::Float,
-            F64Floor => InstructionType::Float,
-            F64Trunc => InstructionType::Float,
-            F64Nearest => InstructionType::Float,
-            F64Sqrt => InstructionType::Float,
-            F64Add => InstructionType::Float,
-            F64Sub => InstructionType::Float,
-            F64Mul => InstructionType::Float,
-            F64Div => InstructionType::Float,
-            F64Min => InstructionType::Float,
-            F64Max => InstructionType::Float,
-            F64Copysign => InstructionType::Float,
-
-            I32WrapI64 => InstructionType::Conversion,
-            I64ExtendSI32 => InstructionType::Conversion,
-            I64ExtendUI32 => InstructionType::Conversion,
-
-            I32TruncSF32 => InstructionType::FloatConversion,
-            I32TruncUF32 => InstructionType::FloatConversion,
-            I32TruncSF64 => InstructionType::FloatConversion,
-            I32TruncUF64 => InstructionType::FloatConversion,
-            I64TruncSF32 => InstructionType::FloatConversion,
-            I64TruncUF32 => InstructionType::FloatConversion,
-            I64TruncSF64 => InstructionType::FloatConversion,
-            I64TruncUF64 => InstructionType::FloatConversion,
-            F32ConvertSI32 => InstructionType::FloatConversion,
-            F32ConvertUI32 => InstructionType::FloatConversion,
-            F32ConvertSI64 => InstructionType::FloatConversion,
-            F32ConvertUI64 => InstructionType::FloatConversion,
-            F32DemoteF64 => InstructionType::FloatConversion,
-            F64ConvertSI32 => InstructionType::FloatConversion,
-            F64ConvertUI32 => InstructionType::FloatConversion,
-            F64ConvertSI64 => InstructionType::FloatConversion,
-            F64ConvertUI64 => InstructionType::FloatConversion,
-            F64PromoteF32 => InstructionType::FloatConversion,
-
-            I32ReinterpretF32 => InstructionType::Reinterpretation,
-            I64ReinterpretF64 => InstructionType::Reinterpretation,
-            F32ReinterpretI32 => InstructionType::Reinterpretation,
-            F64ReinterpretI64 => InstructionType::Reinterpretation,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Set {
-    regular: u32,
-    entries: Map<InstructionType, Metering>,
-    grow: u32,
-}
-
-impl Default for Set {
-    fn default() -> Self {
-        Set {
-            regular: 1,
-            entries: Map::new(),
-            grow: 0,
-        }
-    }
-}
-
-impl Set {
-    pub fn new(regular: u32, entries: Map<InstructionType, Metering>) -> Self {
-        Set { regular: regular, entries: entries, grow: 0 }
-    }
-
-    pub fn process(&self, opcode: &elements::Opcode) -> Result<u32, ()>  {
-        match self.entries.get(&InstructionType::op(opcode)).map(|x| *x) {
-            None | Some(Metering::Regular) => Ok(self.regular),
-            Some(Metering::Forbidden) => Err(()),
-            Some(Metering::Fixed(val)) => Ok(val),
-        }
-    }
-
-    pub fn grow_cost(&self) -> u32 {
-        self.grow
-    }
-
-    pub fn with_grow_cost(mut self, val: u32) -> Self {
-        self.grow = val;
-        self
-    }
-
-    pub fn with_forbidden_floats(mut self) -> Self {
-        self.entries.insert(InstructionType::Float, Metering::Forbidden);
-        self.entries.insert(InstructionType::FloatComparsion, Metering::Forbidden);
-        self.entries.insert(InstructionType::FloatConst, Metering::Forbidden);
-        self.entries.insert(InstructionType::FloatConversion, Metering::Forbidden);
-        self
-    }
-}

src/runtime_type.rs

@@ -1,43 +0,0 @@
-use parity_wasm::{elements, builder};
-use self::elements::{ Module, GlobalEntry, External, ExportEntry, GlobalType, ValueType, InitExpr, Opcode, Internal };
-use byteorder::{ LittleEndian, ByteOrder };
-
-pub fn inject_runtime_type(module: Module, runtime_type: &[u8], runtime_version: u32) -> Module {
-	let runtime_type: u32 = LittleEndian::read_u32(&runtime_type);
-	let globals_count: u32 = match module.global_section() {
-		Some(ref section) => section.entries().len() as u32,
-		None => 0
-	};
-	let imported_globals_count: u32 = match module.import_section() {
-		Some(ref section) => section.entries().iter().filter(|e| match *e.external() {
-			External::Global(ref _a) => true,
-			_ => false
-		}).count() as u32,
-		None => 0
-	};
-	let total_globals_count: u32 = globals_count + imported_globals_count;
-
-	builder::from_module(module)
-		.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(runtime_type as i32), Opcode::End])))
-		.with_export(ExportEntry::new("RUNTIME_TYPE".into(), Internal::Global(total_globals_count)))
-		.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(runtime_version as i32), Opcode::End])))
-		.with_export(ExportEntry::new("RUNTIME_VERSION".into(), Internal::Global(total_globals_count + 1)))
-	.build()
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	#[test]
-	fn it_injects() {
-		let mut module = builder::module()
-			.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(42 as i32)])))
-		.build();
-		module = inject_runtime_type(module, b"emcc", 1);
-		let global_section = module.global_section().expect("Global section expected");
-		assert_eq!(3, global_section.entries().len());
-		let export_section = module.export_section().expect("Export section expected");
-		assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_TYPE" ).is_some());
-		assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_VERSION" ).is_some());
-	}
-}

src/stack_height/mod.rs

@@ -1,436 +0,0 @@
-//! The pass that tries to make stack overflows deterministic, by introducing
-//! an upper bound of the stack size.
-//!
-//! This pass introduces a global mutable variable to track stack height,
-//! and instruments all calls with preamble and postamble.
-//!
-//! Stack height is increased prior the call. Otherwise, the check would
-//! be made after the stack frame is allocated.
-//!
-//! The preamble is inserted before the call. It increments
-//! the global stack height variable with statically determined "stack cost"
-//! of the callee. If after the increment the stack height exceeds
-//! the limit (specified by the `rules`) then execution traps.
-//! Otherwise, the call is executed.
-//!
-//! The postamble is inserted after the call. The purpose of the postamble is to decrease
-//! the stack height by the "stack cost" of the callee function.
-//!
-//! Note, that we can't instrument all possible ways to return from the function. The simplest
-//! example would be a trap issued by the host function.
-//! That means stack height global won't be equal to zero upon the next execution after such trap.
-//!
-//! # Thunks
-//!
-//! Because stack height is increased prior the call few problems arises:
-//!
-//! - Stack height isn't increased upon an entry to the first function, i.e. exported function.
-//! - It is statically unknown what function will be invoked in an indirect call.
-//!
-//! The solution for this problems is to generate a intermediate functions, called 'thunks', which
-//! will increase before and decrease the stack height after the call to original function, and
-//! then make exported function and table entries to point to a corresponding thunks.
-//!
-//! # Stack cost
-//!
-//! Stack cost of the function is calculated as a sum of it's locals
-//! and the maximal height of the value stack.
-//!
-//! All values are treated equally, as they have the same size.
-//!
-//! The rationale for this it makes it possible to use this very naive wasm executor, that is:
-//!
-//! - values are implemented by a union, so each value takes a size equal to
-//!   the size of the largest possible value type this union can hold. (In MVP it is 8 bytes)
-//! - each value from the value stack is placed on the native stack.
-//! - each local variable and function argument is placed on the native stack.
-//! - arguments pushed by the caller are copied into callee stack rather than shared
-//!   between the frames.
-//! - upon entry into the function entire stack frame is allocated.
-
-use std::string::String;
-use std::vec::Vec;
-
-use parity_wasm::elements::{self, Type};
-use parity_wasm::builder;
-
-/// Macro to generate preamble and postamble.
-macro_rules! instrument_call {
-	($callee_idx: expr, $callee_stack_cost: expr, $stack_height_global_idx: expr, $stack_limit: expr) => {{
-		use $crate::parity_wasm::elements::Opcode::*;
-		[
-			// stack_height += stack_cost(F)
-			GetGlobal($stack_height_global_idx),
-			I32Const($callee_stack_cost),
-			I32Add,
-			SetGlobal($stack_height_global_idx),
-			// if stack_counter > LIMIT: unreachable
-			GetGlobal($stack_height_global_idx),
-			I32Const($stack_limit as i32),
-			I32GtU,
-			If(elements::BlockType::NoResult),
-			Unreachable,
-			End,
-			// Original call
-			Call($callee_idx),
-			// stack_height -= stack_cost(F)
-			GetGlobal($stack_height_global_idx),
-			I32Const($callee_stack_cost),
-			I32Sub,
-			SetGlobal($stack_height_global_idx),
-		]
-	}};
-}
-
-mod max_height;
-mod thunk;
-
-/// Error that occured during processing the module.
-///
-/// This means that the module is invalid.
-#[derive(Debug)]
-pub struct Error(String);
-
-pub(crate) struct Context {
-	stack_height_global_idx: Option<u32>,
-	func_stack_costs: Option<Vec<u32>>,
-	stack_limit: u32,
-}
-
-impl Context {
-	/// Returns index in a global index space of a stack_height global variable.
-	///
-	/// Panics if it haven't generated yet.
-	fn stack_height_global_idx(&self) -> u32 {
-		self.stack_height_global_idx.expect(
-			"stack_height_global_idx isn't yet generated;
-			Did you call `inject_stack_counter_global`",
-		)
-	}
-
-	/// Returns `stack_cost` for `func_idx`.
-	///
-	/// Panics if stack costs haven't computed yet or `func_idx` is greater
-	/// than the last function index.
-	fn stack_cost(&self, func_idx: u32) -> Option<u32> {
-		self.func_stack_costs
-			.as_ref()
-			.expect(
-				"func_stack_costs isn't yet computed;
-				Did you call `compute_stack_costs`?",
-			)
-			.get(func_idx as usize)
-			.cloned()
-	}
-
-	/// Returns stack limit specified by the rules.
-	fn stack_limit(&self) -> u32 {
-		self.stack_limit
-	}
-}
-
-/// Instrument a module with stack height limiter.
-///
-/// See module-level documentation for more details.
-///
-/// # Errors
-///
-/// Returns `Err` if module is invalid and can't be
-pub fn inject_limiter(
-	mut module: elements::Module,
-	stack_limit: u32,
-) -> Result<elements::Module, Error> {
-	let mut ctx = Context {
-		stack_height_global_idx: None,
-		func_stack_costs: None,
-		stack_limit,
-	};
-
-	generate_stack_height_global(&mut ctx, &mut module);
-	compute_stack_costs(&mut ctx, &module)?;
-	instrument_functions(&mut ctx, &mut module)?;
-	let module = thunk::generate_thunks(&mut ctx, module)?;
-
-	Ok(module)
-}
-
-/// Generate a new global that will be used for tracking current stack height.
-fn generate_stack_height_global(ctx: &mut Context, module: &mut elements::Module) {
-	let global_entry = builder::global()
-		.value_type()
-		.i32()
-		.mutable()
-		.init_expr(elements::Opcode::I32Const(0))
-		.build();
-
-	// Try to find an existing global section.
-	for section in module.sections_mut() {
-		match *section {
-			elements::Section::Global(ref mut gs) => {
-				gs.entries_mut().push(global_entry);
-
-				let stack_height_global_idx = (gs.entries().len() as u32) - 1;
-				ctx.stack_height_global_idx = Some(stack_height_global_idx);
-				return;
-			}
-			_ => {}
-		}
-	}
-
-	// Existing section not found, create one!
-	module.sections_mut().push(elements::Section::Global(
-		elements::GlobalSection::with_entries(vec![global_entry]),
-	));
-	ctx.stack_height_global_idx = Some(0);
-}
-
-/// Calculate stack costs for all functions.
-///
-/// Returns a vector with a stack cost for each function, including imports.
-fn compute_stack_costs(ctx: &mut Context, module: &elements::Module) -> Result<(), Error> {
-	let func_imports = module.import_count(elements::ImportCountType::Function);
-	let mut func_stack_costs = vec![0; module.functions_space()];
-	// TODO: optimize!
-	for (func_idx, func_stack_cost) in func_stack_costs.iter_mut().enumerate() {
-		// We can't calculate stack_cost of the import functions.
-		if func_idx >= func_imports {
-			*func_stack_cost = compute_stack_cost(func_idx as u32, &module)?;
-		}
-	}
-
-	ctx.func_stack_costs = Some(func_stack_costs);
-	Ok(())
-}
-
-/// Stack cost of the given *defined* function is the sum of it's locals count (that is,
-/// number of arguments plus number of local variables) and the maximal stack
-/// height.
-fn compute_stack_cost(func_idx: u32, module: &elements::Module) -> Result<u32, Error> {
-	// To calculate the cost of a function we need to convert index from
-	// function index space to defined function spaces.
-	let func_imports = module.import_count(elements::ImportCountType::Function) as u32;
-	let defined_func_idx = func_idx.checked_sub(func_imports).ok_or_else(|| {
-		Error("This should be a index of a defined function".into())
-	})?;
-
-	let code_section = module.code_section().ok_or_else(|| {
-		Error("Due to validation code section should exists".into())
-	})?;
-	let body = &code_section
-		.bodies()
-		.get(defined_func_idx as usize)
-		.ok_or_else(|| Error("Function body is out of bounds".into()))?;
-	let locals_count = body.locals().len() as u32;
-
-	let max_stack_height =
-		max_height::compute(
-			defined_func_idx,
-			module
-		)?;
-
-	Ok(locals_count + max_stack_height)
-}
-
-fn instrument_functions(ctx: &mut Context, module: &mut elements::Module) -> Result<(), Error> {
-	for section in module.sections_mut() {
-		match *section {
-			elements::Section::Code(ref mut code_section) => {
-				for func_body in code_section.bodies_mut() {
-					let mut opcodes = func_body.code_mut();
-					instrument_function(ctx, opcodes)?;
-				}
-			}
-			_ => {}
-		}
-	}
-	Ok(())
-}
-
-/// This function searches `call` instructions and wrap each call
-/// with preamble and postamble.
-///
-/// Before:
-///
-/// ```text
-/// get_local 0
-/// get_local 1
-/// call 228
-/// drop
-/// ```
-///
-/// After:
-///
-/// ```text
-/// get_local 0
-/// get_local 1
-///
-/// < ... preamble ... >
-///
-/// call 228
-///
-/// < .. postamble ... >
-///
-/// drop
-/// ```
-fn instrument_function(
-	ctx: &mut Context,
-	opcodes: &mut elements::Opcodes,
-) -> Result<(), Error> {
-	use parity_wasm::elements::Opcode::*;
-
-	let mut cursor = 0;
-	loop {
-		if cursor >= opcodes.elements().len() {
-			break;
-		}
-
-		enum Action {
-			InstrumentCall {
-				callee_idx: u32,
-				callee_stack_cost: u32,
-			},
-			Nop,
-		}
-
-		let action: Action = {
-			let opcode = &opcodes.elements()[cursor];
-			match *opcode {
-				Call(ref callee_idx) => {
-					let callee_stack_cost = ctx
-						.stack_cost(*callee_idx)
-						.ok_or_else(||
-							Error(
-								format!("Call to function that out-of-bounds: {}", callee_idx)
-							)
-						)?;
-
-					// Instrument only calls to a functions which stack_cost is
-					// non-zero.
-					if callee_stack_cost > 0 {
-						Action::InstrumentCall {
-							callee_idx: *callee_idx,
-							callee_stack_cost,
-						}
-					} else {
-						Action::Nop
-					}
-				},
-				_ => Action::Nop,
-			}
-		};
-
-		match action {
-			// We need to wrap a `call idx` instruction
-			// with a code that adjusts stack height counter
-			// and then restores it.
-			Action::InstrumentCall { callee_idx, callee_stack_cost } => {
-				let new_seq = instrument_call!(
-					callee_idx,
-					callee_stack_cost as i32,
-					ctx.stack_height_global_idx(),
-					ctx.stack_limit()
-				);
-
-				// Replace the original `call idx` instruction with
-				// a wrapped call sequence.
-				//
-				// To splice actually take a place, we need to consume iterator
-				// splice returns. So we just `count()` it.
-				let _ = opcodes
-					.elements_mut()
-					.splice(cursor..(cursor + 1), new_seq.iter().cloned())
-					.count();
-
-				// Advance cursor to be after the inserted sequence.
-				cursor += new_seq.len();
-			}
-			// Do nothing for other instructions.
-			_ => {
-				cursor += 1;
-			}
-		}
-	}
-
-	Ok(())
-}
-
-fn resolve_func_type(
-	func_idx: u32,
-	module: &elements::Module,
-) -> Result<&elements::FunctionType, Error> {
-	let types = module.type_section().map(|ts| ts.types()).unwrap_or(&[]);
-	let functions = module
-		.function_section()
-		.map(|fs| fs.entries())
-		.unwrap_or(&[]);
-
-	let func_imports = module.import_count(elements::ImportCountType::Function);
-	let sig_idx = if func_idx < func_imports as u32 {
-		module
-			.import_section()
-			.expect("function import count is not zero; import section must exists; qed")
-			.entries()
-			.iter()
-			.filter_map(|entry| match *entry.external() {
-				elements::External::Function(ref idx) => Some(*idx),
-				_ => None,
-			})
-			.nth(func_idx as usize)
-			.expect(
-				"func_idx is less than function imports count;
-				nth function import must be `Some`;
-				qed",
-			)
-	} else {
-		functions
-			.get(func_idx as usize - func_imports)
-			.ok_or_else(|| Error(format!("Function at index {} is not defined", func_idx)))?
-			.type_ref()
-	};
-	let Type::Function(ref ty) = *types.get(sig_idx as usize).ok_or_else(|| {
-		Error(format!(
-			"Signature {} (specified by func {}) isn't defined",
-			sig_idx, func_idx
-		))
-	})?;
-	Ok(ty)
-}
-
-#[cfg(test)]
-mod tests {
-	extern crate wabt;
-	use parity_wasm::elements;
-	use super::*;
-
-	fn parse_wat(source: &str) -> elements::Module {
-		elements::deserialize_buffer(&wabt::wat2wasm(source).expect("Failed to wat2wasm"))
-			.expect("Failed to deserialize the module")
-	}
-
-	fn validate_module(module: elements::Module) {
-		let binary = elements::serialize(module).expect("Failed to serialize");
-		wabt::Module::read_binary(&binary, &Default::default())
-			.expect("Wabt failed to read final binary")
-			.validate()
-			.expect("Invalid module");
-	}
-
-	#[test]
-	fn test_with_params_and_result() {
-		let module = parse_wat(
-			r#"
-(module
-  (func (export "i32.add") (param i32 i32) (result i32)
-    get_local 0
-	get_local 1
-	i32.add
-  )
-)
-"#,
-		);
-
-		let module = inject_limiter(module, 1024)
-			.expect("Failed to inject stack counter");
-		validate_module(module);
-	}
-}

src/stack_height/thunk.rs

@@ -1,163 +0,0 @@
-#[cfg(features = "std")]
-use std::collections::{HashMap as Map};
-#[cfg(not(features = "std"))]
-use std::collections::{BTreeMap as Map};
-use std::vec::Vec;
-
-use parity_wasm::elements::{self, FunctionType, Internal};
-use parity_wasm::builder;
-
-use super::{resolve_func_type, Context, Error};
-
-struct Thunk {
-	signature: FunctionType,
-	// Index in function space of this thunk.
-	idx: Option<u32>,
-	original_func_idx: u32,
-	callee_stack_cost: u32,
-}
-
-pub(crate) fn generate_thunks(
-	ctx: &mut Context,
-	module: elements::Module,
-) -> Result<elements::Module, Error> {
-	// First, we need to collect all function indicies that should be replaced by thunks
-
-	// Function indicies which needs to generate thunks.
-	let mut need_thunks: Vec<u32> = Vec::new();
-
-	let mut replacement_map: Map<u32, Thunk> = {
-		let exports = module
-			.export_section()
-			.map(|es| es.entries())
-			.unwrap_or(&[]);
-		let elem_segments = module
-			.elements_section()
-			.map(|es| es.entries())
-			.unwrap_or(&[]);
-
-		let exported_func_indicies = exports.iter().filter_map(|entry| match *entry.internal() {
-			Internal::Function(ref function_idx) => Some(*function_idx),
-			_ => None,
-		});
-		let table_func_indicies = elem_segments
-			.iter()
-			.flat_map(|segment| segment.members())
-			.cloned();
-
-		// Replacement map is at least export section size.
-		let mut replacement_map: Map<u32, Thunk> = Map::new();
-
-		for func_idx in exported_func_indicies.chain(table_func_indicies) {
-			let callee_stack_cost = ctx.stack_cost(func_idx).ok_or_else(|| {
-				Error(format!("function with idx {} isn't found", func_idx))
-			})?;
-
-			// Don't generate a thunk if stack_cost of a callee is zero.
-			if callee_stack_cost != 0 {
-				need_thunks.push(func_idx);
-				replacement_map.insert(func_idx, Thunk {
-					signature: resolve_func_type(func_idx, &module)?.clone(),
-					idx: None,
-					callee_stack_cost,
-					original_func_idx: func_idx,
-				});
-			}
-		}
-
-		replacement_map
-	};
-
-	// Then, we generate a thunk for each original function.
-
-	// Save current func_idx
-	let mut next_func_idx = module.functions_space() as u32;
-
-	let mut mbuilder = builder::from_module(module);
-	for func_idx in need_thunks {
-		let mut thunk = replacement_map
-			.get_mut(&func_idx)
-			.expect(
-				"`func_idx` should come from `need_thunks`;
-				`need_thunks` is populated with the same items that in `replacement_map`;
-				qed"
-			);
-
-		let instrumented_call = instrument_call!(
-			thunk.original_func_idx as u32,
-			thunk.callee_stack_cost as i32,
-			ctx.stack_height_global_idx(),
-			ctx.stack_limit()
-		);
-		// Thunk body consist of:
-		//  - argument pushing
-		//  - instrumented call
-		//  - end
-		let mut thunk_body: Vec<elements::Opcode> = Vec::with_capacity(
-			thunk.signature.params().len() +
-			instrumented_call.len() +
-			1
-		);
-
-		for (arg_idx, _) in thunk.signature.params().iter().enumerate() {
-			thunk_body.push(elements::Opcode::GetLocal(arg_idx as u32));
-		}
-		thunk_body.extend(instrumented_call.iter().cloned());
-		thunk_body.push(elements::Opcode::End);
-
-		// TODO: Don't generate a signature, but find an existing one.
-
-		mbuilder = mbuilder.function()
-				// Signature of the thunk should match the original function signature.
-				.signature()
-					.with_params(thunk.signature.params().to_vec())
-					.with_return_type(thunk.signature.return_type().clone())
-					.build()
-				.body()
-					.with_opcodes(elements::Opcodes::new(
-						thunk_body
-					))
-					.build()
-				.build();
-
-		thunk.idx = Some(next_func_idx);
-		next_func_idx += 1;
-	}
-	let mut module = mbuilder.build();
-
-	// And finally, fixup thunks in export and table sections.
-
-	// Fixup original function index to a index of a thunk generated earlier.
-	let fixup = |function_idx: &mut u32| {
-		// Check whether this function is in replacement_map, since
-		// we can skip thunk generation (e.g. if stack_cost of function is 0).
-		if let Some(ref thunk) = replacement_map.get(function_idx) {
-			*function_idx = thunk
-				.idx
-				.expect("At this point an index must be assigned to each thunk");
-		}
-	};
-
-	for section in module.sections_mut() {
-		match *section {
-			elements::Section::Export(ref mut export_section) => {
-				for entry in export_section.entries_mut() {
-					match *entry.internal_mut() {
-						Internal::Function(ref mut function_idx) => fixup(function_idx),
-						_ => {}
-					}
-				}
-			}
-			elements::Section::Element(ref mut elem_section) => {
-				for segment in elem_section.entries_mut() {
-					for function_idx in segment.members_mut() {
-						fixup(function_idx)
-					}
-				}
-			}
-			_ => {}
-		}
-	}
-
-	Ok(module)
-}

src/stack_limiter/max_height.rs

@@ -1,7 +1,15 @@
-use std::vec::Vec;
-
+use super::resolve_func_type;
+use alloc::vec::Vec;
 use parity_wasm::elements::{self, BlockType, Type};
-use super::{resolve_func_type, Error};
+
+#[cfg(feature = "sign_ext")]
+use parity_wasm::elements::SignExtInstruction;
+
+// The cost in stack items that should be charged per call of a function. This is
+// is a static cost that is added to each function call. This makes sense because even
+// if a function does not use any parameters or locals some stack space on the host
+// machine might be consumed to hold some context.
+const ACTIVATION_FRAME_COST: u32 = 2;
 
 /// Control stack frame.
 #[derive(Debug)]
@@ -34,10 +42,7 @@ struct Stack {
 
 impl Stack {
 	fn new() -> Stack {
-		Stack {
-			height: 0,
-			control_stack: Vec::new(),
-		}
+		Stack { height: ACTIVATION_FRAME_COST, control_stack: Vec::new() }
 	}
 
 	/// Returns current height of the value stack.
@@ -47,59 +52,44 @@ impl Stack {
 
 	/// Returns a reference to a frame by specified depth relative to the top of
 	/// control stack.
-	fn frame(&self, rel_depth: u32) -> Result<&Frame, Error> {
+	fn frame(&self, rel_depth: u32) -> Result<&Frame, &'static str> {
 		let control_stack_height: usize = self.control_stack.len();
-		let last_idx = control_stack_height
-			.checked_sub(1)
-			.ok_or_else(|| Error("control stack is empty".into()))?;
-		let idx = last_idx
-			.checked_sub(rel_depth as usize)
-			.ok_or_else(|| Error("control stack out-of-bounds".into()))?;
+		let last_idx = control_stack_height.checked_sub(1).ok_or("control stack is empty")?;
+		let idx = last_idx.checked_sub(rel_depth as usize).ok_or("control stack out-of-bounds")?;
 		Ok(&self.control_stack[idx])
 	}
 
 	/// Mark successive instructions as unreachable.
 	///
 	/// This effectively makes stack polymorphic.
-	fn mark_unreachable(&mut self) -> Result<(), Error> {
-		trace!(target: "max_height", "unreachable");
-		let top_frame = self.control_stack
-			.last_mut()
-			.ok_or_else(|| Error("stack must be non-empty".into()))?;
+	fn mark_unreachable(&mut self) -> Result<(), &'static str> {
+		let top_frame = self.control_stack.last_mut().ok_or("stack must be non-empty")?;
 		top_frame.is_polymorphic = true;
 		Ok(())
 	}
 
 	/// Push control frame into the control stack.
 	fn push_frame(&mut self, frame: Frame) {
-		trace!(target: "max_height", "push_frame: {:?}", frame);
 		self.control_stack.push(frame);
 	}
 
 	/// Pop control frame from the control stack.
 	///
 	/// Returns `Err` if the control stack is empty.
-	fn pop_frame(&mut self) -> Result<Frame, Error> {
-		trace!(target: "max_height", "pop_frame: {:?}", self.control_stack.last());
-		Ok(self.control_stack
-			.pop()
-			.ok_or_else(|| Error("stack must be non-empty".into()))?)
+	fn pop_frame(&mut self) -> Result<Frame, &'static str> {
+		self.control_stack.pop().ok_or("stack must be non-empty")
 	}
 
 	/// Truncate the height of value stack to the specified height.
 	fn trunc(&mut self, new_height: u32) {
-		trace!(target: "max_height", "trunc: {}", new_height);
 		self.height = new_height;
 	}
 
 	/// Push specified number of values into the value stack.
 	///
 	/// Returns `Err` if the height overflow usize value.
-	fn push_values(&mut self, value_count: u32) -> Result<(), Error> {
-		trace!(target: "max_height", "push: {}", value_count);
-		self.height = self.height
-			.checked_add(value_count)
-			.ok_or_else(|| Error("stack overflow".into()))?;
+	fn push_values(&mut self, value_count: u32) -> Result<(), &'static str> {
+		self.height = self.height.checked_add(value_count).ok_or("stack overflow")?;
 		Ok(())
 	}
 
@@ -107,10 +97,9 @@ impl Stack {
 	///
 	/// Returns `Err` if the stack happen to be negative value after
 	/// values popped.
-	fn pop_values(&mut self, value_count: u32) -> Result<(), Error> {
-		trace!(target: "max_height", "pop: {}", value_count);
+	fn pop_values(&mut self, value_count: u32) -> Result<(), &'static str> {
 		if value_count == 0 {
-			return Ok(());
+			return Ok(())
 		}
 		{
 			let top_frame = self.frame(0)?;
@@ -121,51 +110,40 @@ impl Stack {
 				return if top_frame.is_polymorphic {
 					Ok(())
 				} else {
-					Err(Error("trying to pop more values than pushed".into()))
+					return Err("trying to pop more values than pushed")
 				}
 			}
 		}
 
-		self.height = self.height
-			.checked_sub(value_count)
-			.ok_or_else(|| Error("stack underflow".into()))?;
+		self.height = self.height.checked_sub(value_count).ok_or("stack underflow")?;
 
 		Ok(())
 	}
 }
 
 /// This function expects the function to be validated.
-pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, Error> {
-	use parity_wasm::elements::Opcode::*;
+pub fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, &'static str> {
+	use parity_wasm::elements::Instruction::*;
 
-	let func_section = module
-		.function_section()
-		.ok_or_else(|| Error("No function section".into()))?;
-	let code_section = module
-		.code_section()
-		.ok_or_else(|| Error("No code section".into()))?;
-	let type_section = module
-		.type_section()
-		.ok_or_else(|| Error("No type section".into()))?;
-
-
-	trace!(target: "max_height", "func_idx: {}", func_idx);
+	let func_section = module.function_section().ok_or("No function section")?;
+	let code_section = module.code_section().ok_or("No code section")?;
+	let type_section = module.type_section().ok_or("No type section")?;
 
 	// Get a signature and a body of the specified function.
 	let func_sig_idx = func_section
 		.entries()
 		.get(func_idx as usize)
-		.ok_or_else(|| Error("Function is not found in func section".into()))?
+		.ok_or("Function is not found in func section")?
 		.type_ref();
-	let Type::Function(ref func_signature) = *type_section
+	let Type::Function(func_signature) = type_section
 		.types()
 		.get(func_sig_idx as usize)
-		.ok_or_else(|| Error("Function is not found in func section".into()))?;
+		.ok_or("Function is not found in func section")?;
 	let body = code_section
 		.bodies()
 		.get(func_idx as usize)
-		.ok_or_else(|| Error("Function body for the index isn't found".into()))?;
-	let opcodes = body.code();
+		.ok_or("Function body for the index isn't found")?;
+	let instructions = body.code();
 
 	let mut stack = Stack::new();
 	let mut max_height: u32 = 0;
@@ -173,11 +151,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 
 	// Add implicit frame for the function. Breaks to this frame and execution of
 	// the last end should deal with this frame.
-	let func_arity: u32 = if func_signature.return_type().is_some() {
-		1
-	} else {
-		0
-	};
+	let func_arity = func_signature.results().len() as u32;
 	stack.push_frame(Frame {
 		is_polymorphic: false,
 		end_arity: func_arity,
@@ -186,8 +160,8 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 	});
 
 	loop {
-		if pc >= opcodes.elements().len() {
-			break;
+		if pc >= instructions.elements().len() {
+			break
 		}
 
 		// If current value stack is higher than maximal height observed so far,
@@ -197,14 +171,16 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 			max_height = stack.height();
 		}
 
-		let opcode = &opcodes.elements()[pc];
-		trace!(target: "max_height", "{:?}", opcode);
+		let opcode = &instructions.elements()[pc];
 
-		match *opcode {
-			Nop => {}
+		match opcode {
+			Nop => {},
 			Block(ty) | Loop(ty) | If(ty) => {
-				let end_arity = if ty == BlockType::NoResult { 0 } else { 1 };
+				let end_arity = u32::from(*ty != BlockType::NoResult);
 				let branch_arity = if let Loop(_) = *opcode { 0 } else { end_arity };
+				if let If(_) = *opcode {
+					stack.pop_values(1)?;
+				}
 				let height = stack.height();
 				stack.push_frame(Frame {
 					is_polymorphic: false,
@@ -212,31 +188,31 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 					branch_arity,
 					start_height: height,
 				});
-			}
+			},
 			Else => {
 				// The frame at the top should be pushed by `If`. So we leave
 				// it as is.
-			}
+			},
 			End => {
 				let frame = stack.pop_frame()?;
 				stack.trunc(frame.start_height);
 				stack.push_values(frame.end_arity)?;
-			}
+			},
 			Unreachable => {
 				stack.mark_unreachable()?;
-			}
+			},
 			Br(target) => {
 				// Pop values for the destination block result.
-				let target_arity = stack.frame(target)?.branch_arity;
+				let target_arity = stack.frame(*target)?.branch_arity;
 				stack.pop_values(target_arity)?;
 
 				// This instruction unconditionally transfers control to the specified block,
 				// thus all instruction until the end of the current block is deemed unreachable
 				stack.mark_unreachable()?;
-			}
+			},
 			BrIf(target) => {
 				// Pop values for the destination block result.
-				let target_arity = stack.frame(target)?.branch_arity;
+				let target_arity = stack.frame(*target)?.branch_arity;
 				stack.pop_values(target_arity)?;
 
 				// Pop condition value.
@@ -244,17 +220,15 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 
 				// Push values back.
 				stack.push_values(target_arity)?;
-			}
-			BrTable(ref targets, default_target) => {
-				let arity_of_default = stack.frame(default_target)?.branch_arity;
+			},
+			BrTable(br_table_data) => {
+				let arity_of_default = stack.frame(br_table_data.default)?.branch_arity;
 
 				// Check that all jump targets have an equal arities.
-				for target in targets.iter() {
+				for target in &*br_table_data.table {
 					let arity = stack.frame(*target)?.branch_arity;
 					if arity != arity_of_default {
-						return Err(Error(
-							"Arity of all jump-targets must be equal".into()
-						))
+						return Err("Arity of all jump-targets must be equal")
 					}
 				}
 
@@ -265,39 +239,40 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 				// This instruction doesn't let control flow to go further, since the control flow
 				// should take either one of branches depending on the value or the default branch.
 				stack.mark_unreachable()?;
-			}
+			},
 			Return => {
 				// Pop return values of the function. Mark successive instructions as unreachable
 				// since this instruction doesn't let control flow to go further.
 				stack.pop_values(func_arity)?;
 				stack.mark_unreachable()?;
-			}
+			},
 			Call(idx) => {
-				let ty = resolve_func_type(idx, module)?;
+				let ty = resolve_func_type(*idx, module)?;
 
 				// Pop values for arguments of the function.
 				stack.pop_values(ty.params().len() as u32)?;
 
 				// Push result of the function execution to the stack.
-				let callee_arity = if ty.return_type().is_some() { 1 } else { 0 };
+				let callee_arity = ty.results().len() as u32;
 				stack.push_values(callee_arity)?;
-			}
+			},
 			CallIndirect(x, _) => {
-				let Type::Function(ref ty) = *type_section
-					.types()
-					.get(x as usize)
-					.ok_or_else(|| Error("Type not found".into()))?;
+				let Type::Function(ty) =
+					type_section.types().get(*x as usize).ok_or("Type not found")?;
+
+				// Pop the offset into the function table.
+				stack.pop_values(1)?;
 
 				// Pop values for arguments of the function.
 				stack.pop_values(ty.params().len() as u32)?;
 
 				// Push result of the function execution to the stack.
-				let callee_arity = if ty.return_type().is_some() { 1 } else { 0 };
+				let callee_arity = ty.results().len() as u32;
 				stack.push_values(callee_arity)?;
-			}
+			},
 			Drop => {
 				stack.pop_values(1)?;
-			}
+			},
 			Select => {
 				// Pop two values and one condition.
 				stack.pop_values(2)?;
@@ -305,118 +280,128 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 
 				// Push the selected value.
 				stack.push_values(1)?;
-			}
+			},
 			GetLocal(_) => {
 				stack.push_values(1)?;
-			}
+			},
 			SetLocal(_) => {
 				stack.pop_values(1)?;
-			}
+			},
 			TeeLocal(_) => {
 				// This instruction pops and pushes the value, so
 				// effectively it doesn't modify the stack height.
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
 			GetGlobal(_) => {
 				stack.push_values(1)?;
-			}
+			},
 			SetGlobal(_) => {
 				stack.pop_values(1)?;
-			}
-			I32Load(_, _)
-			| I64Load(_, _)
-			| F32Load(_, _)
-			| F64Load(_, _)
-			| I32Load8S(_, _)
-			| I32Load8U(_, _)
-			| I32Load16S(_, _)
-			| I32Load16U(_, _)
-			| I64Load8S(_, _)
-			| I64Load8U(_, _)
-			| I64Load16S(_, _)
-			| I64Load16U(_, _)
-			| I64Load32S(_, _)
-			| I64Load32U(_, _) => {
+			},
+			I32Load(_, _) |
+			I64Load(_, _) |
+			F32Load(_, _) |
+			F64Load(_, _) |
+			I32Load8S(_, _) |
+			I32Load8U(_, _) |
+			I32Load16S(_, _) |
+			I32Load16U(_, _) |
+			I64Load8S(_, _) |
+			I64Load8U(_, _) |
+			I64Load16S(_, _) |
+			I64Load16U(_, _) |
+			I64Load32S(_, _) |
+			I64Load32U(_, _) => {
 				// These instructions pop the address and pushes the result,
 				// which effictively don't modify the stack height.
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
 
-			I32Store(_, _)
-			| I64Store(_, _)
-			| F32Store(_, _)
-			| F64Store(_, _)
-			| I32Store8(_, _)
-			| I32Store16(_, _)
-			| I64Store8(_, _)
-			| I64Store16(_, _)
-			| I64Store32(_, _) => {
+			I32Store(_, _) |
+			I64Store(_, _) |
+			F32Store(_, _) |
+			F64Store(_, _) |
+			I32Store8(_, _) |
+			I32Store16(_, _) |
+			I64Store8(_, _) |
+			I64Store16(_, _) |
+			I64Store32(_, _) => {
 				// These instructions pop the address and the value.
 				stack.pop_values(2)?;
-			}
+			},
 
 			CurrentMemory(_) => {
 				// Pushes current memory size
 				stack.push_values(1)?;
-			}
+			},
 			GrowMemory(_) => {
 				// Grow memory takes the value of pages to grow and pushes
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
 
 			I32Const(_) | I64Const(_) | F32Const(_) | F64Const(_) => {
 				// These instructions just push the single literal value onto the stack.
 				stack.push_values(1)?;
-			}
+			},
 
 			I32Eqz | I64Eqz => {
 				// These instructions pop the value and compare it against zero, and pushes
 				// the result of the comparison.
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
 
-			I32Eq | I32Ne | I32LtS | I32LtU | I32GtS | I32GtU | I32LeS | I32LeU | I32GeS
-			| I32GeU | I64Eq | I64Ne | I64LtS | I64LtU | I64GtS | I64GtU | I64LeS | I64LeU
-			| I64GeS | I64GeU | F32Eq | F32Ne | F32Lt | F32Gt | F32Le | F32Ge | F64Eq | F64Ne
-			| F64Lt | F64Gt | F64Le | F64Ge => {
+			I32Eq | I32Ne | I32LtS | I32LtU | I32GtS | I32GtU | I32LeS | I32LeU | I32GeS |
+			I32GeU | I64Eq | I64Ne | I64LtS | I64LtU | I64GtS | I64GtU | I64LeS | I64LeU |
+			I64GeS | I64GeU | F32Eq | F32Ne | F32Lt | F32Gt | F32Le | F32Ge | F64Eq | F64Ne |
+			F64Lt | F64Gt | F64Le | F64Ge => {
 				// Comparison operations take two operands and produce one result.
 				stack.pop_values(2)?;
 				stack.push_values(1)?;
-			}
+			},
 
-			I32Clz | I32Ctz | I32Popcnt | I64Clz | I64Ctz | I64Popcnt | F32Abs | F32Neg
-			| F32Ceil | F32Floor | F32Trunc | F32Nearest | F32Sqrt | F64Abs | F64Neg | F64Ceil
-			| F64Floor | F64Trunc | F64Nearest | F64Sqrt => {
+			I32Clz | I32Ctz | I32Popcnt | I64Clz | I64Ctz | I64Popcnt | F32Abs | F32Neg |
+			F32Ceil | F32Floor | F32Trunc | F32Nearest | F32Sqrt | F64Abs | F64Neg | F64Ceil |
+			F64Floor | F64Trunc | F64Nearest | F64Sqrt => {
 				// Unary operators take one operand and produce one result.
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
 
-			I32Add | I32Sub | I32Mul | I32DivS | I32DivU | I32RemS | I32RemU | I32And | I32Or
-			| I32Xor | I32Shl | I32ShrS | I32ShrU | I32Rotl | I32Rotr | I64Add | I64Sub
-			| I64Mul | I64DivS | I64DivU | I64RemS | I64RemU | I64And | I64Or | I64Xor | I64Shl
-			| I64ShrS | I64ShrU | I64Rotl | I64Rotr | F32Add | F32Sub | F32Mul | F32Div
-			| F32Min | F32Max | F32Copysign | F64Add | F64Sub | F64Mul | F64Div | F64Min
-			| F64Max | F64Copysign => {
+			I32Add | I32Sub | I32Mul | I32DivS | I32DivU | I32RemS | I32RemU | I32And | I32Or |
+			I32Xor | I32Shl | I32ShrS | I32ShrU | I32Rotl | I32Rotr | I64Add | I64Sub |
+			I64Mul | I64DivS | I64DivU | I64RemS | I64RemU | I64And | I64Or | I64Xor | I64Shl |
+			I64ShrS | I64ShrU | I64Rotl | I64Rotr | F32Add | F32Sub | F32Mul | F32Div |
+			F32Min | F32Max | F32Copysign | F64Add | F64Sub | F64Mul | F64Div | F64Min |
+			F64Max | F64Copysign => {
 				// Binary operators take two operands and produce one result.
 				stack.pop_values(2)?;
 				stack.push_values(1)?;
-			}
+			},
 
-			I32WrapI64 | I32TruncSF32 | I32TruncUF32 | I32TruncSF64 | I32TruncUF64
-			| I64ExtendSI32 | I64ExtendUI32 | I64TruncSF32 | I64TruncUF32 | I64TruncSF64
-			| I64TruncUF64 | F32ConvertSI32 | F32ConvertUI32 | F32ConvertSI64 | F32ConvertUI64
-			| F32DemoteF64 | F64ConvertSI32 | F64ConvertUI32 | F64ConvertSI64 | F64ConvertUI64
-			| F64PromoteF32 | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32
-			| F64ReinterpretI64 => {
+			I32WrapI64 | I32TruncSF32 | I32TruncUF32 | I32TruncSF64 | I32TruncUF64 |
+			I64ExtendSI32 | I64ExtendUI32 | I64TruncSF32 | I64TruncUF32 | I64TruncSF64 |
+			I64TruncUF64 | F32ConvertSI32 | F32ConvertUI32 | F32ConvertSI64 | F32ConvertUI64 |
+			F32DemoteF64 | F64ConvertSI32 | F64ConvertUI32 | F64ConvertSI64 | F64ConvertUI64 |
+			F64PromoteF32 | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32 |
+			F64ReinterpretI64 => {
 				// Conversion operators take one value and produce one result.
 				stack.pop_values(1)?;
 				stack.push_values(1)?;
-			}
+			},
+
+			#[cfg(feature = "sign_ext")]
+			SignExt(SignExtInstruction::I32Extend8S) |
+			SignExt(SignExtInstruction::I32Extend16S) |
+			SignExt(SignExtInstruction::I64Extend8S) |
+			SignExt(SignExtInstruction::I64Extend16S) |
+			SignExt(SignExtInstruction::I64Extend32S) => {
+				stack.pop_values(1)?;
+				stack.push_values(1)?;
+			},
 		}
 		pc += 1;
 	}
@@ -426,12 +411,11 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result<u32, E
 
 #[cfg(test)]
 mod tests {
-	extern crate wabt;
-	use parity_wasm::elements;
 	use super::*;
+	use parity_wasm::elements;
 
 	fn parse_wat(source: &str) -> elements::Module {
-		elements::deserialize_buffer(&wabt::wat2wasm(source).expect("Failed to wat2wasm"))
+		elements::deserialize_buffer(&wat::parse_str(source).expect("Failed to wat2wasm"))
 			.expect("Failed to deserialize the module")
 	}
 
@@ -453,7 +437,7 @@ mod tests {
 		);
 
 		let height = compute(0, &module).unwrap();
-		assert_eq!(height, 3);
+		assert_eq!(height, 3 + ACTIVATION_FRAME_COST);
 	}
 
 	#[test]
@@ -470,7 +454,7 @@ mod tests {
 		);
 
 		let height = compute(0, &module).unwrap();
-		assert_eq!(height, 1);
+		assert_eq!(height, 1 + ACTIVATION_FRAME_COST);
 	}
 
 	#[test]
@@ -481,46 +465,114 @@ mod tests {
   (memory 0)
   (func (result i32)
 	unreachable
-	grow_memory
+	memory.grow
   )
 )
 "#,
 		);
 
 		let height = compute(0, &module).unwrap();
-		assert_eq!(height, 0);
+		assert_eq!(height, ACTIVATION_FRAME_COST);
 	}
 
 	#[test]
 	fn yet_another_test() {
-		const SOURCE: &'static str = r#"
+		let module = parse_wat(
+			r#"
 (module
   (memory 0)
   (func
-    ;; Push two values and then pop them.
-    ;; This will make max depth to be equal to 2.
-    i32.const 0
-    i32.const 1
-    drop
-    drop
+	;; Push two values and then pop them.
+	;; This will make max depth to be equal to 2.
+	i32.const 0
+	i32.const 1
+	drop
+	drop
 
-    ;; Code after `unreachable` shouldn't have an effect
-    ;; on the max depth.
-    unreachable
-    i32.const 0
-    i32.const 1
-    i32.const 2
+	;; Code after `unreachable` shouldn't have an effect
+	;; on the max depth.
+	unreachable
+	i32.const 0
+	i32.const 1
+	i32.const 2
   )
 )
-"#;
-		let module = elements::deserialize_buffer(&wabt::Wat2Wasm::new()
-			.validate(false)
-			.convert(SOURCE)
-			.expect("Failed to wat2wasm")
-			.as_ref())
-			.expect("Failed to deserialize the module");
+"#,
+		);
 
 		let height = compute(0, &module).unwrap();
-		assert_eq!(height, 2);
+		assert_eq!(height, 2 + ACTIVATION_FRAME_COST);
+	}
+
+	#[test]
+	fn call_indirect() {
+		let module = parse_wat(
+			r#"
+(module
+	(table $ptr 1 1 funcref)
+	(elem $ptr (i32.const 0) func 1)
+	(func $main
+		(call_indirect (i32.const 0))
+		(call_indirect (i32.const 0))
+		(call_indirect (i32.const 0))
+	)
+	(func $callee
+		i64.const 42
+		drop
+	)
+)
+"#,
+		);
+
+		let height = compute(0, &module).unwrap();
+		assert_eq!(height, 1 + ACTIVATION_FRAME_COST);
+	}
+
+	#[test]
+	fn breaks() {
+		let module = parse_wat(
+			r#"
+(module
+	(func $main
+		block (result i32)
+			block (result i32)
+				i32.const 99
+				br 1
+			end
+		end
+		drop
+	)
+)
+"#,
+		);
+
+		let height = compute(0, &module).unwrap();
+		assert_eq!(height, 1 + ACTIVATION_FRAME_COST);
+	}
+
+	#[test]
+	fn if_else_works() {
+		let module = parse_wat(
+			r#"
+(module
+	(func $main
+		i32.const 7
+		i32.const 1
+		if (result i32)
+			i32.const 42
+		else
+			i32.const 99
+		end
+		i32.const 97
+		drop
+		drop
+		drop
+	)
+)
+"#,
+		);
+
+		let height = compute(0, &module).unwrap();
+		assert_eq!(height, 3 + ACTIVATION_FRAME_COST);
 	}
 }

src/stack_limiter/mod.rs

@@ -0,0 +1,380 @@
+//! Contains the code for the stack height limiter instrumentation.
+
+use alloc::{vec, vec::Vec};
+use core::mem;
+use parity_wasm::{
+	builder,
+	elements::{self, Instruction, Instructions, Type},
+};
+
+/// Macro to generate preamble and postamble.
+macro_rules! instrument_call {
+	($callee_idx: expr, $callee_stack_cost: expr, $stack_height_global_idx: expr, $stack_limit: expr) => {{
+		use $crate::parity_wasm::elements::Instruction::*;
+		[
+			// stack_height += stack_cost(F)
+			GetGlobal($stack_height_global_idx),
+			I32Const($callee_stack_cost),
+			I32Add,
+			SetGlobal($stack_height_global_idx),
+			// if stack_counter > LIMIT: unreachable
+			GetGlobal($stack_height_global_idx),
+			I32Const($stack_limit as i32),
+			I32GtU,
+			If(elements::BlockType::NoResult),
+			Unreachable,
+			End,
+			// Original call
+			Call($callee_idx),
+			// stack_height -= stack_cost(F)
+			GetGlobal($stack_height_global_idx),
+			I32Const($callee_stack_cost),
+			I32Sub,
+			SetGlobal($stack_height_global_idx),
+		]
+	}};
+}
+
+mod max_height;
+mod thunk;
+
+pub struct Context {
+	stack_height_global_idx: u32,
+	func_stack_costs: Vec<u32>,
+	stack_limit: u32,
+}
+
+impl Context {
+	/// Returns index in a global index space of a stack_height global variable.
+	fn stack_height_global_idx(&self) -> u32 {
+		self.stack_height_global_idx
+	}
+
+	/// Returns `stack_cost` for `func_idx`.
+	fn stack_cost(&self, func_idx: u32) -> Option<u32> {
+		self.func_stack_costs.get(func_idx as usize).cloned()
+	}
+
+	/// Returns stack limit specified by the rules.
+	fn stack_limit(&self) -> u32 {
+		self.stack_limit
+	}
+}
+
+/// Inject the instumentation that makes stack overflows deterministic, by introducing
+/// an upper bound of the stack size.
+///
+/// This pass introduces a global mutable variable to track stack height,
+/// and instruments all calls with preamble and postamble.
+///
+/// Stack height is increased prior the call. Otherwise, the check would
+/// be made after the stack frame is allocated.
+///
+/// The preamble is inserted before the call. It increments
+/// the global stack height variable with statically determined "stack cost"
+/// of the callee. If after the increment the stack height exceeds
+/// the limit (specified by the `rules`) then execution traps.
+/// Otherwise, the call is executed.
+///
+/// The postamble is inserted after the call. The purpose of the postamble is to decrease
+/// the stack height by the "stack cost" of the callee function.
+///
+/// Note, that we can't instrument all possible ways to return from the function. The simplest
+/// example would be a trap issued by the host function.
+/// That means stack height global won't be equal to zero upon the next execution after such trap.
+///
+/// # Thunks
+///
+/// Because stack height is increased prior the call few problems arises:
+///
+/// - Stack height isn't increased upon an entry to the first function, i.e. exported function.
+/// - Start function is executed externally (similar to exported functions).
+/// - It is statically unknown what function will be invoked in an indirect call.
+///
+/// The solution for this problems is to generate a intermediate functions, called 'thunks', which
+/// will increase before and decrease the stack height after the call to original function, and
+/// then make exported function and table entries, start section to point to a corresponding thunks.
+///
+/// # Stack cost
+///
+/// Stack cost of the function is calculated as a sum of it's locals
+/// and the maximal height of the value stack.
+///
+/// All values are treated equally, as they have the same size.
+///
+/// The rationale is that this makes it possible to use the following very naive wasm executor:
+///
+/// - values are implemented by a union, so each value takes a size equal to the size of the largest
+///   possible value type this union can hold. (In MVP it is 8 bytes)
+/// - each value from the value stack is placed on the native stack.
+/// - each local variable and function argument is placed on the native stack.
+/// - arguments pushed by the caller are copied into callee stack rather than shared between the
+///   frames.
+/// - upon entry into the function entire stack frame is allocated.
+pub fn inject(
+	mut module: elements::Module,
+	stack_limit: u32,
+) -> Result<elements::Module, &'static str> {
+	let mut ctx = Context {
+		stack_height_global_idx: generate_stack_height_global(&mut module),
+		func_stack_costs: compute_stack_costs(&module)?,
+		stack_limit,
+	};
+
+	instrument_functions(&mut ctx, &mut module)?;
+	let module = thunk::generate_thunks(&mut ctx, module)?;
+
+	Ok(module)
+}
+
+/// Generate a new global that will be used for tracking current stack height.
+fn generate_stack_height_global(module: &mut elements::Module) -> u32 {
+	let global_entry = builder::global()
+		.value_type()
+		.i32()
+		.mutable()
+		.init_expr(Instruction::I32Const(0))
+		.build();
+
+	// Try to find an existing global section.
+	for section in module.sections_mut() {
+		if let elements::Section::Global(gs) = section {
+			gs.entries_mut().push(global_entry);
+			return (gs.entries().len() as u32) - 1
+		}
+	}
+
+	// Existing section not found, create one!
+	module
+		.sections_mut()
+		.push(elements::Section::Global(elements::GlobalSection::with_entries(vec![global_entry])));
+	0
+}
+
+/// Calculate stack costs for all functions.
+///
+/// Returns a vector with a stack cost for each function, including imports.
+fn compute_stack_costs(module: &elements::Module) -> Result<Vec<u32>, &'static str> {
+	let func_imports = module.import_count(elements::ImportCountType::Function);
+
+	// TODO: optimize!
+	(0..module.functions_space())
+		.map(|func_idx| {
+			if func_idx < func_imports {
+				// We can't calculate stack_cost of the import functions.
+				Ok(0)
+			} else {
+				compute_stack_cost(func_idx as u32, module)
+			}
+		})
+		.collect()
+}
+
+/// Stack cost of the given *defined* function is the sum of it's locals count (that is,
+/// number of arguments plus number of local variables) and the maximal stack
+/// height.
+fn compute_stack_cost(func_idx: u32, module: &elements::Module) -> Result<u32, &'static str> {
+	// To calculate the cost of a function we need to convert index from
+	// function index space to defined function spaces.
+	let func_imports = module.import_count(elements::ImportCountType::Function) as u32;
+	let defined_func_idx = func_idx
+		.checked_sub(func_imports)
+		.ok_or("This should be a index of a defined function")?;
+
+	let code_section =
+		module.code_section().ok_or("Due to validation code section should exists")?;
+	let body = &code_section
+		.bodies()
+		.get(defined_func_idx as usize)
+		.ok_or("Function body is out of bounds")?;
+
+	let mut locals_count: u32 = 0;
+	for local_group in body.locals() {
+		locals_count =
+			locals_count.checked_add(local_group.count()).ok_or("Overflow in local count")?;
+	}
+
+	let max_stack_height = max_height::compute(defined_func_idx, module)?;
+
+	locals_count
+		.checked_add(max_stack_height)
+		.ok_or("Overflow in adding locals_count and max_stack_height")
+}
+
+fn instrument_functions(
+	ctx: &mut Context,
+	module: &mut elements::Module,
+) -> Result<(), &'static str> {
+	for section in module.sections_mut() {
+		if let elements::Section::Code(code_section) = section {
+			for func_body in code_section.bodies_mut() {
+				let opcodes = func_body.code_mut();
+				instrument_function(ctx, opcodes)?;
+			}
+		}
+	}
+	Ok(())
+}
+
+/// This function searches `call` instructions and wrap each call
+/// with preamble and postamble.
+///
+/// Before:
+///
+/// ```text
+/// local.get 0
+/// local.get 1
+/// call 228
+/// drop
+/// ```
+///
+/// After:
+///
+/// ```text
+/// local.get 0
+/// local.get 1
+///
+/// < ... preamble ... >
+///
+/// call 228
+///
+/// < .. postamble ... >
+///
+/// drop
+/// ```
+fn instrument_function(ctx: &mut Context, func: &mut Instructions) -> Result<(), &'static str> {
+	use Instruction::*;
+
+	struct InstrumentCall {
+		offset: usize,
+		callee: u32,
+		cost: u32,
+	}
+
+	let calls: Vec<_> = func
+		.elements()
+		.iter()
+		.enumerate()
+		.filter_map(|(offset, instruction)| {
+			if let Call(callee) = instruction {
+				ctx.stack_cost(*callee).and_then(|cost| {
+					if cost > 0 {
+						Some(InstrumentCall { callee: *callee, offset, cost })
+					} else {
+						None
+					}
+				})
+			} else {
+				None
+			}
+		})
+		.collect();
+
+	// The `instrumented_call!` contains the call itself. This is why we need to subtract one.
+	let len = func.elements().len() + calls.len() * (instrument_call!(0, 0, 0, 0).len() - 1);
+	let original_instrs = mem::replace(func.elements_mut(), Vec::with_capacity(len));
+	let new_instrs = func.elements_mut();
+
+	let mut calls = calls.into_iter().peekable();
+	for (original_pos, instr) in original_instrs.into_iter().enumerate() {
+		// whether there is some call instruction at this position that needs to be instrumented
+		let did_instrument = if let Some(call) = calls.peek() {
+			if call.offset == original_pos {
+				let new_seq = instrument_call!(
+					call.callee,
+					call.cost as i32,
+					ctx.stack_height_global_idx(),
+					ctx.stack_limit()
+				);
+				new_instrs.extend_from_slice(&new_seq);
+				true
+			} else {
+				false
+			}
+		} else {
+			false
+		};
+
+		if did_instrument {
+			calls.next();
+		} else {
+			new_instrs.push(instr);
+		}
+	}
+
+	if calls.next().is_some() {
+		return Err("Not all calls were used")
+	}
+
+	Ok(())
+}
+
+fn resolve_func_type(
+	func_idx: u32,
+	module: &elements::Module,
+) -> Result<&elements::FunctionType, &'static str> {
+	let types = module.type_section().map(|ts| ts.types()).unwrap_or(&[]);
+	let functions = module.function_section().map(|fs| fs.entries()).unwrap_or(&[]);
+
+	let func_imports = module.import_count(elements::ImportCountType::Function);
+	let sig_idx = if func_idx < func_imports as u32 {
+		module
+			.import_section()
+			.expect("function import count is not zero; import section must exists; qed")
+			.entries()
+			.iter()
+			.filter_map(|entry| match entry.external() {
+				elements::External::Function(idx) => Some(*idx),
+				_ => None,
+			})
+			.nth(func_idx as usize)
+			.expect(
+				"func_idx is less than function imports count;
+				nth function import must be `Some`;
+				qed",
+			)
+	} else {
+		functions
+			.get(func_idx as usize - func_imports)
+			.ok_or("Function at the specified index is not defined")?
+			.type_ref()
+	};
+	let Type::Function(ty) = types
+		.get(sig_idx as usize)
+		.ok_or("The signature as specified by a function isn't defined")?;
+	Ok(ty)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use parity_wasm::elements;
+
+	fn parse_wat(source: &str) -> elements::Module {
+		elements::deserialize_buffer(&wat::parse_str(source).expect("Failed to wat2wasm"))
+			.expect("Failed to deserialize the module")
+	}
+
+	fn validate_module(module: elements::Module) {
+		let binary = elements::serialize(module).expect("Failed to serialize");
+		wasmparser::validate(&binary).expect("Invalid module");
+	}
+
+	#[test]
+	fn test_with_params_and_result() {
+		let module = parse_wat(
+			r#"
+(module
+	(func (export "i32.add") (param i32 i32) (result i32)
+		local.get 0
+		local.get 1
+		i32.add
+	)
+)
+"#,
+		);
+
+		let module = inject(module, 1024).expect("Failed to inject stack counter");
+		validate_module(module);
+	}
+}

src/stack_limiter/thunk.rs

@@ -0,0 +1,135 @@
+use alloc::{collections::BTreeMap as Map, vec::Vec};
+use parity_wasm::{
+	builder,
+	elements::{self, FunctionType, Internal},
+};
+
+use super::{resolve_func_type, Context};
+
+struct Thunk {
+	signature: FunctionType,
+	// Index in function space of this thunk.
+	idx: Option<u32>,
+	callee_stack_cost: u32,
+}
+
+pub fn generate_thunks(
+	ctx: &mut Context,
+	module: elements::Module,
+) -> Result<elements::Module, &'static str> {
+	// First, we need to collect all function indices that should be replaced by thunks
+	let mut replacement_map: Map<u32, Thunk> = {
+		let exports = module.export_section().map(|es| es.entries()).unwrap_or(&[]);
+		let elem_segments = module.elements_section().map(|es| es.entries()).unwrap_or(&[]);
+		let start_func_idx = module.start_section();
+
+		let exported_func_indices = exports.iter().filter_map(|entry| match entry.internal() {
+			Internal::Function(function_idx) => Some(*function_idx),
+			_ => None,
+		});
+		let table_func_indices =
+			elem_segments.iter().flat_map(|segment| segment.members()).cloned();
+
+		// Replacement map is at least export section size.
+		let mut replacement_map: Map<u32, Thunk> = Map::new();
+
+		for func_idx in exported_func_indices
+			.chain(table_func_indices)
+			.chain(start_func_idx.into_iter())
+		{
+			let callee_stack_cost = ctx.stack_cost(func_idx).ok_or("function index isn't found")?;
+
+			// Don't generate a thunk if stack_cost of a callee is zero.
+			if callee_stack_cost != 0 {
+				replacement_map.insert(
+					func_idx,
+					Thunk {
+						signature: resolve_func_type(func_idx, &module)?.clone(),
+						idx: None,
+						callee_stack_cost,
+					},
+				);
+			}
+		}
+
+		replacement_map
+	};
+
+	// Then, we generate a thunk for each original function.
+
+	// Save current func_idx
+	let mut next_func_idx = module.functions_space() as u32;
+
+	let mut mbuilder = builder::from_module(module);
+	for (func_idx, thunk) in replacement_map.iter_mut() {
+		let instrumented_call = instrument_call!(
+			*func_idx,
+			thunk.callee_stack_cost as i32,
+			ctx.stack_height_global_idx(),
+			ctx.stack_limit()
+		);
+		// Thunk body consist of:
+		//  - argument pushing
+		//  - instrumented call
+		//  - end
+		let mut thunk_body: Vec<elements::Instruction> =
+			Vec::with_capacity(thunk.signature.params().len() + instrumented_call.len() + 1);
+
+		for (arg_idx, _) in thunk.signature.params().iter().enumerate() {
+			thunk_body.push(elements::Instruction::GetLocal(arg_idx as u32));
+		}
+		thunk_body.extend_from_slice(&instrumented_call);
+		thunk_body.push(elements::Instruction::End);
+
+		// TODO: Don't generate a signature, but find an existing one.
+
+		mbuilder = mbuilder
+			.function()
+			// Signature of the thunk should match the original function signature.
+			.signature()
+			.with_params(thunk.signature.params().to_vec())
+			.with_results(thunk.signature.results().to_vec())
+			.build()
+			.body()
+			.with_instructions(elements::Instructions::new(thunk_body))
+			.build()
+			.build();
+
+		thunk.idx = Some(next_func_idx);
+		next_func_idx += 1;
+	}
+	let mut module = mbuilder.build();
+
+	// And finally, fixup thunks in export and table sections.
+
+	// Fixup original function index to a index of a thunk generated earlier.
+	let fixup = |function_idx: &mut u32| {
+		// Check whether this function is in replacement_map, since
+		// we can skip thunk generation (e.g. if stack_cost of function is 0).
+		if let Some(thunk) = replacement_map.get(function_idx) {
+			*function_idx =
+				thunk.idx.expect("At this point an index must be assigned to each thunk");
+		}
+	};
+
+	for section in module.sections_mut() {
+		match section {
+			elements::Section::Export(export_section) =>
+				for entry in export_section.entries_mut() {
+					if let Internal::Function(function_idx) = entry.internal_mut() {
+						fixup(function_idx)
+					}
+				},
+			elements::Section::Element(elem_section) =>
+				for segment in elem_section.entries_mut() {
+					for function_idx in segment.members_mut() {
+						fixup(function_idx)
+					}
+				},
+			elements::Section::Start(start_idx) => fixup(start_idx),
+			_ => {},
+		}
+	}
+
+	Ok(module)
+}

src/symbols.rs

@@ -1,157 +0,0 @@
-#[cfg(features = "std")]
-use std::collections::{HashSet as Set};
-#[cfg(not(features = "std"))]
-use std::collections::{BTreeSet as Set};
-use std::vec::Vec;
-
-use parity_wasm::elements;
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
-pub enum Symbol {
-	Type(usize),
-	Import(usize),
-	Global(usize),
-	Function(usize),
-	Export(usize),
-}
-
-pub fn resolve_function(module: &elements::Module, index: u32) -> Symbol {
-	let mut functions = 0;
-	if let Some(import_section) = module.import_section() {
-		for (item_index, item) in import_section.entries().iter().enumerate() {
-			match item.external() {
-				&elements::External::Function(_) => {
-					if functions == index {
-						return Symbol::Import(item_index as usize);
-					}
-					functions += 1;
-				},
-				_ => {}
-			}
-		}
-	}
-
-	Symbol::Function(index as usize - functions as usize)
-}
-
-pub fn resolve_global(module: &elements::Module, index: u32) -> Symbol {
-	let mut globals = 0;
-	if let Some(import_section) = module.import_section() {
-		for (item_index, item) in import_section.entries().iter().enumerate() {
-			match item.external() {
-				&elements::External::Global(_) => {
-					if globals == index {
-						return Symbol::Import(item_index as usize);
-					}
-					globals += 1;
-				},
-				_ => {}
-			}
-		}
-	}
-
-	Symbol::Global(index as usize - globals as usize)
-}
-
-pub fn push_code_symbols(module: &elements::Module, opcodes: &[elements::Opcode], dest: &mut Vec<Symbol>) {
-	use parity_wasm::elements::Opcode::*;
-
-	for opcode in opcodes {
-		match opcode {
-			&Call(idx) => {
-				dest.push(resolve_function(module, idx));
-			},
-			&CallIndirect(idx, _) => {
-				dest.push(Symbol::Type(idx as usize));
-			},
-			&GetGlobal(idx) | &SetGlobal(idx) => {
-				dest.push(resolve_global(module, idx))
-			},
-			_ => { },
-		}
-	}
-}
-
-pub fn expand_symbols(module: &elements::Module, set: &mut Set<Symbol>) {
-	use self::Symbol::*;
-
-	// symbols that were already processed
-	let mut stop: Set<Symbol> = Set::new();
-	let mut fringe = set.iter().cloned().collect::<Vec<Symbol>>();
-	loop {
-		let next = match fringe.pop() {
-			Some(s) if stop.contains(&s) => { continue; }
-			Some(s) => s,
-			_ => { break; }
-		};
-		trace!("Processing symbol {:?}", next);
-
-		match next {
-			Export(idx) => {
-				let entry = &module.export_section().expect("Export section to exist").entries()[idx];
-				match entry.internal() {
-					&elements::Internal::Function(func_idx) => {
-						let symbol = resolve_function(module, func_idx);
-						if !stop.contains(&symbol) {
-							fringe.push(symbol);
-						}
-						set.insert(symbol);
-					},
-					&elements::Internal::Global(global_idx) => {
-						let symbol = resolve_global(module, global_idx);
-						if !stop.contains(&symbol) {
-							fringe.push(symbol);
-						}
-						set.insert(symbol);
-					},
-					_ => {}
-				}
-			},
-			Import(idx) => {
-				let entry = &module.import_section().expect("Import section to exist").entries()[idx];
-				match entry.external() {
-					&elements::External::Function(type_idx) => {
-						let type_symbol = Symbol::Type(type_idx as usize);
-						if !stop.contains(&type_symbol) {
-							fringe.push(type_symbol);
-						}
-						set.insert(type_symbol);
-					},
-					_ => {}
-				}
-			},
-			Function(idx) => {
-				let body = &module.code_section().expect("Code section to exist").bodies()[idx];
-				let mut code_symbols = Vec::new();
-				push_code_symbols(module, body.code().elements(), &mut code_symbols);
-				for symbol in code_symbols.drain(..) {
-					if !stop.contains(&symbol) {
-						fringe.push(symbol);
-					}
-					set.insert(symbol);
-				}
-
-				let signature = &module.function_section().expect("Functions section to exist").entries()[idx];
-				let type_symbol = Symbol::Type(signature.type_ref() as usize);
-				if !stop.contains(&type_symbol) {
-					fringe.push(type_symbol);
-				}
-				set.insert(type_symbol);
-			},
-			Global(idx) => {
-				let entry = &module.global_section().expect("Global section to exist").entries()[idx];
-				let mut code_symbols = Vec::new();
-				push_code_symbols(module, entry.init_expr().code(), &mut code_symbols);
-				for symbol in code_symbols.drain(..) {
-					if !stop.contains(&symbol) {
-						fringe.push(symbol);
-					}
-					set.insert(symbol);
-				}
-			}
-			_ => {}
-		}
-
-		stop.insert(next);
-	}
-}

tests/diff.rs

@@ -1,18 +1,16 @@
-extern crate diff;
-extern crate pwasm_utils as utils;
-extern crate wabt;
-extern crate parity_wasm;
-
-use std::fs;
-use std::io::{self, Read, Write};
-use std::path::{Path, PathBuf};
-use parity_wasm::elements;
+use std::{
+	fs,
+	io::{self, Read, Write},
+	path::{Path, PathBuf},
+};
+use wasm_instrument::{self as instrument, gas_metering, parity_wasm::elements};
+use wasmparser::validate;
 
 fn slurp<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
-    let mut f = fs::File::open(path)?;
-    let mut buf = vec![];
-    f.read_to_end(&mut buf)?;
-    Ok(buf)
+	let mut f = fs::File::open(path)?;
+	let mut buf = vec![];
+	f.read_to_end(&mut buf)?;
+	Ok(buf)
 }
 
 fn dump<P: AsRef<Path>>(path: P, buf: &[u8]) -> io::Result<()> {
@@ -21,46 +19,41 @@ fn dump<P: AsRef<Path>>(path: P, buf: &[u8]) -> io::Result<()> {
 	Ok(())
 }
 
-fn validate_wasm(binary: &[u8]) -> Result<(), wabt::Error> {
-	wabt::Module::read_binary(
-		&binary,
-		&Default::default()
-	)?.validate()?;
-	Ok(())
-}
-
-fn run_diff_test<F: FnOnce(&[u8]) -> Vec<u8>>(test_dir: &str, name: &str, test: F) {
-	let mut fixture_path = PathBuf::from(concat!(
-		env!("CARGO_MANIFEST_DIR"),
-		"/tests/fixtures/",
-	));
+fn run_diff_test<F: FnOnce(&[u8]) -> Vec<u8>>(
+	test_dir: &str,
+	in_name: &str,
+	out_name: &str,
+	test: F,
+) {
+	let mut fixture_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+	fixture_path.push("tests");
+	fixture_path.push("fixtures");
 	fixture_path.push(test_dir);
-	fixture_path.push(name);
+	fixture_path.push(in_name);
 
-	let mut expected_path = PathBuf::from(concat!(
-		env!("CARGO_MANIFEST_DIR"),
-		"/tests/expectations/"
-	));
+	let mut expected_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+	expected_path.push("tests");
+	expected_path.push("expectations");
 	expected_path.push(test_dir);
-	expected_path.push(name);
+	expected_path.push(out_name);
 
-	let fixture_wat = slurp(&fixture_path).expect("Failed to read fixture");
-	let fixture_wasm = wabt::wat2wasm(fixture_wat).expect("Failed to read fixture");
-	validate_wasm(&fixture_wasm).expect("Fixture is invalid");
+	let fixture_wasm = wat::parse_file(&fixture_path).expect("Failed to read fixture");
+	validate(&fixture_wasm).expect("Fixture is invalid");
 
 	let expected_wat = slurp(&expected_path).unwrap_or_default();
-	let expected_wat = String::from_utf8_lossy(&expected_wat);
+	let expected_wat = std::str::from_utf8(&expected_wat).expect("Failed to decode expected wat");
 
 	let actual_wasm = test(fixture_wasm.as_ref());
-	validate_wasm(&actual_wasm).expect("Result module is invalid");
+	validate(&actual_wasm).expect("Result module is invalid");
 
-	let actual_wat = wabt::wasm2wat(&actual_wasm).expect("Failed to convert result wasm to wat");
+	let actual_wat =
+		wasmprinter::print_bytes(&actual_wasm).expect("Failed to convert result wasm to wat");
 
 	if actual_wat != expected_wat {
 		println!("difference!");
 		println!("--- {}", expected_path.display());
-		println!("+++ {} test {}", test_dir, name);
-		for diff in diff::lines(&expected_wat, &actual_wat) {
+		println!("+++ {} test {}", test_dir, out_name);
+		for diff in diff::lines(expected_wat, &actual_wat) {
 			match diff {
 				diff::Result::Left(l) => println!("-{}", l),
 				diff::Result::Both(l, _) => println!(" {}", l),
@@ -68,26 +61,97 @@ fn run_diff_test<F: FnOnce(&[u8]) -> Vec<u8>>(test_dir: &str, name: &str, test:
 			}
 		}
 
-		dump(&expected_path, actual_wat.as_bytes()).expect("Failed to write to expected");
-
-		panic!();
+		if std::env::var_os("BLESS").is_some() {
+			dump(&expected_path, actual_wat.as_bytes()).expect("Failed to write to expected");
+		} else {
+			panic!();
+		}
 	}
 }
 
-macro_rules! def_stack_height_test {
-	( $name:ident ) => {
-		#[test]
-		fn $name() {
-			run_diff_test("stack-height", concat!(stringify!($name), ".wat"), |input| {
-				let module = elements::deserialize_buffer(input).expect("Failed to deserialize");
-				let instrumented = utils::stack_height::inject_limiter(module, 1024).expect("Failed to instrument with stack counter");
-				elements::serialize(instrumented).expect("Failed to serialize")
-			});
-		}
-	};
+mod stack_height {
+	use super::*;
+
+	macro_rules! def_stack_height_test {
+		( $name:ident ) => {
+			#[test]
+			fn $name() {
+				run_diff_test(
+					"stack-height",
+					concat!(stringify!($name), ".wat"),
+					concat!(stringify!($name), ".wat"),
+					|input| {
+						let module =
+							elements::deserialize_buffer(input).expect("Failed to deserialize");
+						let instrumented = instrument::inject_stack_limiter(module, 1024)
+							.expect("Failed to instrument with stack counter");
+						elements::serialize(instrumented).expect("Failed to serialize")
+					},
+				);
+			}
+		};
+	}
+
+	def_stack_height_test!(simple);
+	def_stack_height_test!(start);
+	def_stack_height_test!(table);
+	def_stack_height_test!(global);
+	def_stack_height_test!(imports);
+	def_stack_height_test!(many_locals);
+	def_stack_height_test!(empty_functions);
 }
 
-def_stack_height_test!(simple);
-def_stack_height_test!(table);
-def_stack_height_test!(global);
-def_stack_height_test!(imports);
+mod gas {
+	use super::*;
+
+	macro_rules! def_gas_test {
+		( ($input:ident, $name1:ident, $name2:ident) ) => {
+			#[test]
+			fn $name1() {
+				run_diff_test(
+					"gas",
+					concat!(stringify!($input), ".wat"),
+					concat!(stringify!($name1), ".wat"),
+					|input| {
+						let rules = gas_metering::ConstantCostRules::default();
+
+						let module: elements::Module =
+							elements::deserialize_buffer(input).expect("Failed to deserialize");
+						let module = module.parse_names().expect("Failed to parse names");
+						let backend = gas_metering::host_function::Injector::new("env", "gas");
+
+						let instrumented = gas_metering::inject(module, backend, &rules)
+							.expect("Failed to instrument with gas metering");
+						elements::serialize(instrumented).expect("Failed to serialize")
+					},
+				);
+			}
+
+			#[test]
+			fn $name2() {
+				run_diff_test(
+					"gas",
+					concat!(stringify!($input), ".wat"),
+					concat!(stringify!($name2), ".wat"),
+					|input| {
+						let rules = gas_metering::ConstantCostRules::default();
+
+						let module: elements::Module =
+							elements::deserialize_buffer(input).expect("Failed to deserialize");
+						let module = module.parse_names().expect("Failed to parse names");
+						let backend = gas_metering::mutable_global::Injector::new("gas_left");
+						let instrumented = gas_metering::inject(module, backend, &rules)
+							.expect("Failed to instrument with gas metering");
+						elements::serialize(instrumented).expect("Failed to serialize")
+					},
+				);
+			}
+		};
+	}
+
+	def_gas_test!((ifs, ifs_host_fn, ifs_mut_global));
+	def_gas_test!((simple, simple_host_fn, simple_mut_global));
+	def_gas_test!((start, start_host_fn, start_mut_global));
+	def_gas_test!((call, call_host_fn, call_mut_global));
+	def_gas_test!((branch, branch_host_fn, branch_mut_global));
+}

tests/expectations/gas/branch_host_fn.wat

@@ -0,0 +1,31 @@
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i64)))
+  (import "env" "gas" (func (;0;) (type 1)))
+  (func $fibonacci_with_break (;1;) (type 0) (result i32)
+    (local i32 i32)
+    i64.const 15
+    call 0
+    block ;; label = @1
+      i32.const 0
+      local.set 0
+      i32.const 1
+      local.set 1
+      local.get 0
+      local.get 1
+      local.tee 0
+      i32.add
+      local.set 1
+      i32.const 1
+      br_if 0 (;@1;)
+      i64.const 5
+      call 0
+      local.get 0
+      local.get 1
+      local.tee 0
+      i32.add
+      local.set 1
+    end
+    local.get 1
+  )
+)

tests/expectations/gas/branch_mut_global.wat

@@ -0,0 +1,47 @@
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i64)))
+  (func $fibonacci_with_break (;0;) (type 0) (result i32)
+    (local $x i32) (local $y i32)
+    i64.const 26
+    call 1
+    block ;; label = @1
+      i32.const 0
+      local.set $x
+      i32.const 1
+      local.set $y
+      local.get $x
+      local.get $y
+      local.tee $x
+      i32.add
+      local.set $y
+      i32.const 1
+      br_if 0 (;@1;)
+      i64.const 16
+      call 1
+      local.get $x
+      local.get $y
+      local.tee $x
+      i32.add
+      local.set $y
+    end
+    local.get $y
+  )
+  (func (;1;) (type 1) (param i64)
+    global.get 0
+    local.get 0
+    i64.ge_u
+    if ;; label = @1
+      global.get 0
+      local.get 0
+      i64.sub
+      global.set 0
+    else
+      i64.const -1
+      global.set 0
+      unreachable
+    end
+  )
+  (global (;0;) (mut i64) i64.const 0)
+  (export "gas_left" (global 0))
+)

tests/expectations/gas/call_host_fn.wat

@@ -0,0 +1,22 @@
+(module
+  (type (;0;) (func (param i32 i32) (result i32)))
+  (type (;1;) (func (param i64)))
+  (import "env" "gas" (func (;0;) (type 1)))
+  (func $add_locals (;1;) (type 0) (param $x i32) (param $y i32) (result i32)
+    (local i32)
+    i64.const 6
+    call 0
+    local.get $x
+    local.get $y
+    call $add
+    local.set 2
+    local.get 2
+  )
+  (func $add (;2;) (type 0) (param i32 i32) (result i32)
+    i64.const 3
+    call 0
+    local.get 0
+    local.get 1
+    i32.add
+  )
+)

tests/expectations/gas/call_mut_global.wat

@@ -0,0 +1,38 @@
+(module
+  (type (;0;) (func (param i32 i32) (result i32)))
+  (type (;1;) (func (param i64)))
+  (func $add_locals (;0;) (type 0) (param $x i32) (param $y i32) (result i32)
+    (local $t i32)
+    i64.const 17
+    call 2
+    local.get $x
+    local.get $y
+    call $add
+    local.set $t
+    local.get $t
+  )
+  (func $add (;1;) (type 0) (param $x i32) (param $y i32) (result i32)
+    i64.const 14
+    call 2
+    local.get $x
+    local.get $y
+    i32.add
+  )
+  (func (;2;) (type 1) (param i64)
+    global.get 0
+    local.get 0
+    i64.ge_u
+    if ;; label = @1
+      global.get 0
+      local.get 0
+      i64.sub
+      global.set 0
+    else
+      i64.const -1
+      global.set 0
+      unreachable
+    end
+  )
+  (global (;0;) (mut i64) i64.const 0)
+  (export "gas_left" (global 0))
+)

tests/expectations/gas/ifs_host_fn.wat

@@ -0,0 +1,22 @@
+(module
+  (type (;0;) (func (param i32) (result i32)))
+  (type (;1;) (func (param i64)))
+  (import "env" "gas" (func (;0;) (type 1)))
+  (func (;1;) (type 0) (param i32) (result i32)
+    i64.const 2
+    call 0
+    i32.const 1
+    if (result i32) ;; label = @1
+      i64.const 3
+      call 0
+      local.get 0
+      i32.const 1
+      i32.add
+    else
+      i64.const 2
+      call 0
+      local.get 0
+      i32.popcnt
+    end
+  )
+)

tests/expectations/gas/ifs_mut_global.wat

@@ -0,0 +1,38 @@
+(module
+  (type (;0;) (func (param i32) (result i32)))
+  (type (;1;) (func (param i64)))
+  (func (;0;) (type 0) (param $x i32) (result i32)
+    i64.const 13
+    call 1
+    i32.const 1
+    if (result i32) ;; label = @1
+      i64.const 14
+      call 1
+      local.get $x
+      i32.const 1
+      i32.add
+    else
+      i64.const 13
+      call 1
+      local.get $x
+      i32.popcnt
+    end
+  )
+  (func (;1;) (type 1) (param i64)
+    global.get 0
+    local.get 0
+    i64.ge_u
+    if ;; label = @1
+      global.get 0
+      local.get 0
+      i64.sub
+      global.set 0
+    else
+      i64.const -1
+      global.set 0
+      unreachable
+    end
+  )
+  (global (;0;) (mut i64) i64.const 0)
+  (export "gas_left" (global 0))
+)

tests/expectations/gas/simple_host_fn.wat

@@ -0,0 +1,27 @@
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i64)))
+  (import "env" "gas" (func (;0;) (type 1)))
+  (func (;1;) (type 0)
+    i64.const 2
+    call 0
+    i32.const 1
+    if ;; label = @1
+      i64.const 1
+      call 0
+      loop ;; label = @2
+        i64.const 2
+        call 0
+        i32.const 123
+        drop
+      end
+    end
+  )
+  (func (;2;) (type 0)
+    i64.const 1
+    call 0
+    block ;; label = @1
+    end
+  )
+  (export "simple" (func 1))
+)

tests/expectations/gas/simple_mut_global.wat

@@ -0,0 +1,43 @@
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i64)))
+  (func (;0;) (type 0)
+    i64.const 13
+    call 2
+    i32.const 1
+    if ;; label = @1
+      i64.const 12
+      call 2
+      loop ;; label = @2
+        i64.const 13
+        call 2
+        i32.const 123
+        drop
+      end
+    end
+  )
+  (func (;1;) (type 0)
+    i64.const 12
+    call 2
+    block ;; label = @1
+    end
+  )
+  (func (;2;) (type 1) (param i64)
+    global.get 0
+    local.get 0
+    i64.ge_u
+    if ;; label = @1
+      global.get 0
+      local.get 0
+      i64.sub
+      global.set 0
+    else
+      i64.const -1
+      global.set 0
+      unreachable
+    end
+  )
+  (global (;0;) (mut i64) i64.const 0)
+  (export "simple" (func 0))
+  (export "gas_left" (global 0))
+)

tests/expectations/gas/start_host_fn.wat

@@ -0,0 +1,20 @@
+(module
+  (type (;0;) (func (param i32 i32)))
+  (type (;1;) (func))
+  (type (;2;) (func (param i64)))
+  (import "env" "ext_return" (func $ext_return (;0;) (type 0)))
+  (import "env" "memory" (memory (;0;) 1 1))
+  (import "env" "gas" (func (;1;) (type 2)))
+  (func $start (;2;) (type 1)
+    i64.const 4
+    call 1
+    i32.const 8
+    i32.const 4
+    call $ext_return
+    unreachable
+  )
+  (func (;3;) (type 1))
+  (export "call" (func 3))
+  (start $start)
+  (data (;0;) (i32.const 8) "\01\02\03\04")
+)

tests/expectations/gas/start_mut_global.wat

@@ -0,0 +1,36 @@
+(module
+  (type (;0;) (func (param i32 i32)))
+  (type (;1;) (func))
+  (type (;2;) (func (param i64)))
+  (import "env" "ext_return" (func $ext_return (;0;) (type 0)))
+  (import "env" "memory" (memory (;0;) 1 1))
+  (func $start (;1;) (type 1)
+    i64.const 15
+    call 3
+    i32.const 8
+    i32.const 4
+    call $ext_return
+    unreachable
+  )
+  (func (;2;) (type 1))
+  (func (;3;) (type 2) (param i64)
+    global.get 0
+    local.get 0
+    i64.ge_u
+    if ;; label = @1
+      global.get 0
+      local.get 0
+      i64.sub
+      global.set 0
+    else
+      i64.const -1
+      global.set 0
+      unreachable
+    end
+  )
+  (global (;0;) (mut i64) i64.const 0)
+  (export "call" (func 2))
+  (export "gas_left" (global 0))
+  (start $start)
+  (data (;0;) (i32.const 8) "\01\02\03\04")
+)

tests/expectations/stack-height/empty_functions.wat

@@ -0,0 +1,56 @@
+(module
+  (type (;0;) (func))
+  (func (;0;) (type 0)
+    global.get 0
+    i32.const 2
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call 0
+    global.get 0
+    i32.const 2
+    i32.sub
+    global.set 0
+  )
+  (func (;1;) (type 0)
+    global.get 0
+    i32.const 2
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call 0
+    global.get 0
+    i32.const 2
+    i32.sub
+    global.set 0
+  )
+  (func (;2;) (type 0)
+    global.get 0
+    i32.const 2
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call 1
+    global.get 0
+    i32.const 2
+    i32.sub
+    global.set 0
+  )
+  (global (;0;) (mut i32) i32.const 0)
+  (export "main" (func 2))
+)

tests/expectations/stack-height/global.wat

@@ -2,55 +2,58 @@
   (type (;0;) (func))
   (type (;1;) (func (param i32 i32) (result i32)))
   (type (;2;) (func (param i32)))
-  (type (;3;) (func (param i32 i32) (result i32)))
-  (import "env" "foo" (func (;0;) (type 0)))
-  (func (;1;) (type 1) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    i32.add)
-  (func (;2;) (type 2) (param i32)
-    (local i32)
-    get_global 0
+  (import "env" "foo" (func $foo (;0;) (type 0)))
+  (func $i32.add (;1;) (type 1) (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    i32.add
+  )
+  (func (;2;) (type 2) (param $arg i32)
+    (local $tmp i32)
+    global.get $counter
     i32.const 1
     i32.add
-    tee_local 1
-    set_global 0
-    get_local 1
-    get_local 0
-    get_global 1
-    i32.const 2
+    local.tee $tmp
+    global.set $counter
+    local.get $tmp
+    local.get $arg
+    global.get 1
+    i32.const 4
     i32.add
-    set_global 1
-    get_global 1
+    global.set 1
+    global.get 1
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
-    call 1
-    get_global 1
-    i32.const 2
+    call $i32.add
+    global.get 1
+    i32.const 4
     i32.sub
-    set_global 1
-    drop)
-  (func (;3;) (type 3) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    get_global 1
-    i32.const 2
+    global.set 1
+    drop
+  )
+  (func (;3;) (type 1) (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    global.get 1
+    i32.const 4
     i32.add
-    set_global 1
-    get_global 1
+    global.set 1
+    global.get 1
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
-    call 1
-    get_global 1
-    i32.const 2
+    call $i32.add
+    global.get 1
+    i32.const 4
     i32.sub
-    set_global 1)
-  (global (;0;) (mut i32) (i32.const 1))
-  (global (;1;) (mut i32) (i32.const 0))
-  (export "i32.add" (func 3)))
+    global.set 1
+  )
+  (global $counter (;0;) (mut i32) i32.const 1)
+  (global (;1;) (mut i32) i32.const 0)
+  (export "i32.add" (func 3))
+)

tests/expectations/stack-height/imports.wat

@@ -1,32 +1,34 @@
 (module
   (type (;0;) (func))
   (type (;1;) (func (param i32 i32) (result i32)))
-  (type (;2;) (func (param i32 i32) (result i32)))
-  (import "env" "foo" (func (;0;) (type 0)))
-  (import "env" "boo" (func (;1;) (type 0)))
+  (import "env" "foo" (func $foo (;0;) (type 0)))
+  (import "env" "boo" (func $boo (;1;) (type 0)))
   (func (;2;) (type 1) (param i32 i32) (result i32)
-    call 0
-    call 1
-    get_local 0
-    get_local 1
-    i32.add)
-  (func (;3;) (type 2) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    get_global 0
-    i32.const 2
+    call $foo
+    call $boo
+    local.get 0
+    local.get 1
     i32.add
-    set_global 0
-    get_global 0
+  )
+  (func (;3;) (type 1) (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    global.get 0
+    i32.const 4
+    i32.add
+    global.set 0
+    global.get 0
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
     call 2
-    get_global 0
-    i32.const 2
+    global.get 0
+    i32.const 4
     i32.sub
-    set_global 0)
-  (global (;0;) (mut i32) (i32.const 0))
-  (export "i32.add" (func 3)))
+    global.set 0
+  )
+  (global (;0;) (mut i32) i32.const 0)
+  (export "i32.add" (func 3))
+)

tests/expectations/stack-height/many_locals.wat

@@ -0,0 +1,24 @@
+(module
+  (type (;0;) (func))
+  (func $one-group-many-locals (;0;) (type 0)
+    (local i64 i64 i32)
+  )
+  (func $main (;1;) (type 0)
+    global.get 0
+    i32.const 5
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call $one-group-many-locals
+    global.get 0
+    i32.const 5
+    i32.sub
+    global.set 0
+  )
+  (global (;0;) (mut i32) i32.const 0)
+)

tests/expectations/stack-height/simple.wat

@@ -1,24 +1,26 @@
 (module
   (type (;0;) (func))
-  (type (;1;) (func))
   (func (;0;) (type 0)
     i32.const 123
-    drop)
-  (func (;1;) (type 1)
-    get_global 0
-    i32.const 1
+    drop
+  )
+  (func (;1;) (type 0)
+    global.get 0
+    i32.const 3
     i32.add
-    set_global 0
-    get_global 0
+    global.set 0
+    global.get 0
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
     call 0
-    get_global 0
-    i32.const 1
+    global.get 0
+    i32.const 3
     i32.sub
-    set_global 0)
-  (global (;0;) (mut i32) (i32.const 0))
-  (export "simple" (func 1)))
+    global.set 0
+  )
+  (global (;0;) (mut i32) i32.const 0)
+  (export "simple" (func 1))
+)

tests/expectations/stack-height/start.wat

@@ -0,0 +1,47 @@
+(module
+  (type (;0;) (func (param i32 i32)))
+  (type (;1;) (func))
+  (import "env" "ext_return" (func $ext_return (;0;) (type 0)))
+  (import "env" "memory" (memory (;0;) 1 1))
+  (func $start (;1;) (type 1)
+    (local i32)
+  )
+  (func (;2;) (type 1))
+  (func (;3;) (type 1)
+    global.get 0
+    i32.const 3
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call $start
+    global.get 0
+    i32.const 3
+    i32.sub
+    global.set 0
+  )
+  (func (;4;) (type 1)
+    global.get 0
+    i32.const 2
+    i32.add
+    global.set 0
+    global.get 0
+    i32.const 1024
+    i32.gt_u
+    if ;; label = @1
+      unreachable
+    end
+    call 2
+    global.get 0
+    i32.const 2
+    i32.sub
+    global.set 0
+  )
+  (global (;0;) (mut i32) i32.const 0)
+  (export "call" (func 4))
+  (start 3)
+)

tests/expectations/stack-height/table.wat

@@ -2,87 +2,71 @@
   (type (;0;) (func))
   (type (;1;) (func (param i32)))
   (type (;2;) (func (param i32 i32) (result i32)))
-  (type (;3;) (func (param i32 i32) (result i32)))
-  (type (;4;) (func (param i32)))
-  (type (;5;) (func (param i32 i32) (result i32)))
-  (import "env" "foo" (func (;0;) (type 0)))
+  (import "env" "foo" (func $foo (;0;) (type 0)))
   (func (;1;) (type 1) (param i32)
-    get_local 0
+    local.get 0
     i32.const 0
-    get_global 0
-    i32.const 2
+    global.get 0
+    i32.const 4
     i32.add
-    set_global 0
-    get_global 0
+    global.set 0
+    global.get 0
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
-    call 2
-    get_global 0
-    i32.const 2
+    call $i32.add
+    global.get 0
+    i32.const 4
     i32.sub
-    set_global 0
-    drop)
-  (func (;2;) (type 2) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    i32.add)
-  (func (;3;) (type 3) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    get_global 0
-    i32.const 2
+    global.set 0
+    drop
+  )
+  (func $i32.add (;2;) (type 2) (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
     i32.add
-    set_global 0
-    get_global 0
+  )
+  (func (;3;) (type 1) (param i32)
+    local.get 0
+    global.get 0
+    i32.const 4
+    i32.add
+    global.set 0
+    global.get 0
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
-      unreachable
-    end
-    call 2
-    get_global 0
-    i32.const 2
-    i32.sub
-    set_global 0)
-  (func (;4;) (type 4) (param i32)
-    get_local 0
-    get_global 0
-    i32.const 2
-    i32.add
-    set_global 0
-    get_global 0
-    i32.const 1024
-    i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
     call 1
-    get_global 0
-    i32.const 2
+    global.get 0
+    i32.const 4
     i32.sub
-    set_global 0)
-  (func (;5;) (type 5) (param i32 i32) (result i32)
-    get_local 0
-    get_local 1
-    get_global 0
-    i32.const 2
+    global.set 0
+  )
+  (func (;4;) (type 2) (param i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    global.get 0
+    i32.const 4
     i32.add
-    set_global 0
-    get_global 0
+    global.set 0
+    global.get 0
     i32.const 1024
     i32.gt_u
-    if  ;; label = @1
+    if ;; label = @1
       unreachable
     end
-    call 2
-    get_global 0
-    i32.const 2
+    call $i32.add
+    global.get 0
+    i32.const 4
     i32.sub
-    set_global 0)
-  (table (;0;) 10 anyfunc)
-  (global (;0;) (mut i32) (i32.const 0))
-  (export "i32.add" (func 5))
-  (elem (i32.const 0) 0 4 5))
+    global.set 0
+  )
+  (table (;0;) 10 funcref)
+  (global (;0;) (mut i32) i32.const 0)
+  (export "i32.add" (func 4))
+  (elem (;0;) (i32.const 0) func $foo 3 4)
+)

tests/fixtures/gas/branch.wat

@@ -0,0 +1,27 @@
+(module
+	(func $fibonacci_with_break (result i32)
+		(local $x i32) (local $y i32)
+
+		(block $unrolled_loop
+			(local.set $x (i32.const 0))
+			(local.set $y (i32.const 1))
+
+			local.get $x
+			local.get $y
+			local.tee $x
+			i32.add
+			local.set $y
+
+			i32.const 1
+			br_if $unrolled_loop
+
+			local.get $x
+			local.get $y
+			local.tee $x
+			i32.add
+			local.set $y
+		)
+
+		local.get $y
+	)
+)

tests/fixtures/gas/call.wat

@@ -0,0 +1,19 @@
+(module
+	(func $add_locals (param $x i32) (param $y i32) (result i32)
+		(local $t i32)
+
+		local.get $x
+		local.get $y
+		call $add
+		local.set $t
+
+		local.get $t
+	)
+
+	(func $add (param $x i32) (param $y i32) (result i32)
+		(i32.add
+			(local.get $x)
+			(local.get $y)
+		)
+	)
+)

tests/fixtures/gas/ifs.wat

@@ -0,0 +1,9 @@
+(module
+	(func (param $x i32) (result i32)
+		(if (result i32)
+			(i32.const 1)
+			(then (i32.add (local.get $x) (i32.const 1)))
+			(else (i32.popcnt (local.get $x)))
+		)
+	)
+)

tests/fixtures/gas/simple.wat

@@ -0,0 +1,17 @@
+(module
+	(func (export "simple")
+		(if (i32.const 1)
+			(then
+				(loop
+					i32.const 123
+					drop
+				)
+			)
+		)
+	)
+
+	(func
+		block
+		end
+	)
+)

tests/fixtures/gas/start.wat

@@ -0,0 +1,18 @@
+(module
+	(import "env" "ext_return" (func $ext_return (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(start $start)
+	(func $start
+		(call $ext_return
+			(i32.const 8)
+			(i32.const 4)
+		)
+		(unreachable)
+	)
+
+	(func (export "call")
+	)
+
+	(data (i32.const 8) "\01\02\03\04")
+)

tests/fixtures/stack-height/empty_functions.wat

@@ -0,0 +1,8 @@
+(module
+  (func (;0;)
+    call 0
+  )
+  (func (;1;) (export "main")
+    call 0
+  )
+)

tests/fixtures/stack-height/global.wat

@@ -5,22 +5,22 @@
   (global $counter (mut i32) (i32.const 1))
 
   (func $i32.add (export "i32.add") (param i32 i32) (result i32)
-    get_local 0
-	get_local 1
-	i32.add
+    local.get 0
+    local.get 1
+    i32.add
   )
   (func (param $arg i32)
-     (local $tmp i32)
+    (local $tmp i32)
 
-     get_global 0
-     i32.const 1
-     i32.add
-	 tee_local $tmp
-     set_global $counter
+    global.get 0
+    i32.const 1
+    i32.add
+    local.tee $tmp
+    global.set $counter
 
-     get_local $tmp
-     get_local $arg
-     call $i32.add
-     drop
+    local.get $tmp
+    local.get $arg
+    call $i32.add
+    drop
   )
 )

tests/fixtures/stack-height/imports.wat

@@ -8,8 +8,8 @@
     call $foo
     call $boo
 
-    get_local 0
-    get_local 1
+    local.get 0
+    local.get 1
     i32.add
   )
 )

tests/fixtures/stack-height/many_locals.wat

@@ -0,0 +1,10 @@
+(module
+	(func $one-group-many-locals
+		(local i64) (local i64) (local i32)
+	)
+	(func $main
+		(call
+			$one-group-many-locals
+		)
+	)
+)

tests/fixtures/stack-height/start.wat

@@ -0,0 +1,11 @@
+(module
+	(import "env" "ext_return" (func $ext_return (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(start $start)
+	(func $start
+		(local i32)
+	)
+	(func (export "call")
+	)
+)

tests/fixtures/stack-height/table.wat

@@ -1,17 +1,17 @@
 (module
   (import "env" "foo" (func $foo))
   (func (param i32)
-     get_local 0
-     i32.const 0
-     call $i32.add
-     drop
+    local.get 0
+    i32.const 0
+    call $i32.add
+    drop
   )
   (func $i32.add (export "i32.add") (param i32 i32) (result i32)
-    get_local 0
-	get_local 1
-	i32.add
+    local.get 0
+    local.get 1
+    i32.add
   )
-  (table 10 anyfunc)
+  (table 10 funcref)
 
   ;; Refer all types of functions: imported, defined not exported and defined exported.
   (elem (i32.const 0) 0 1 2)

tests/overhead.rs

@@ -0,0 +1,171 @@
+use std::{
+	fs::{read, read_dir, ReadDir},
+	path::PathBuf,
+};
+use wasm_instrument::{
+	gas_metering::{self, host_function, mutable_global, ConstantCostRules},
+	inject_stack_limiter,
+	parity_wasm::{deserialize_buffer, elements::Module, serialize},
+};
+
+fn fixture_dir() -> PathBuf {
+	let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+	path.push("benches");
+	path.push("fixtures");
+	path
+}
+
+use gas_metering::Backend;
+fn gas_metered_mod_len<B: Backend>(orig_module: Module, backend: B) -> (Module, usize) {
+	let module = gas_metering::inject(orig_module, backend, &ConstantCostRules::default()).unwrap();
+	let bytes = serialize(module.clone()).unwrap();
+	let len = bytes.len();
+	(module, len)
+}
+
+fn stack_limited_mod_len(module: Module) -> (Module, usize) {
+	let module = inject_stack_limiter(module, 128).unwrap();
+	let bytes = serialize(module.clone()).unwrap();
+	let len = bytes.len();
+	(module, len)
+}
+
+struct InstrumentedWasmResults {
+	filename: String,
+	original_module_len: usize,
+	stack_limited_len: usize,
+	gas_metered_host_fn_len: usize,
+	gas_metered_mut_glob_len: usize,
+	gas_metered_host_fn_then_stack_limited_len: usize,
+	gas_metered_mut_glob_then_stack_limited_len: usize,
+}
+
+fn size_overheads_all(files: ReadDir) -> Vec<InstrumentedWasmResults> {
+	files
+		.map(|entry| {
+			let entry = entry.unwrap();
+			let filename = entry.file_name().into_string().unwrap();
+
+			let (original_module_len, orig_module) = {
+				let bytes = match entry.path().extension().unwrap().to_str() {
+					Some("wasm") => read(entry.path()).unwrap(),
+					Some("wat") =>
+						wat::parse_bytes(&read(entry.path()).unwrap()).unwrap().into_owned(),
+					_ => panic!("expected fixture_dir containing .wasm or .wat files only"),
+				};
+
+				let len = bytes.len();
+				let module: Module = deserialize_buffer(&bytes).unwrap();
+				(len, module)
+			};
+
+			let (gm_host_fn_module, gas_metered_host_fn_len) = gas_metered_mod_len(
+				orig_module.clone(),
+				host_function::Injector::new("env", "gas"),
+			);
+
+			let (gm_mut_global_module, gas_metered_mut_glob_len) =
+				gas_metered_mod_len(orig_module.clone(), mutable_global::Injector::new("gas_left"));
+
+			let stack_limited_len = stack_limited_mod_len(orig_module).1;
+
+			let (_gm_hf_sl_mod, gas_metered_host_fn_then_stack_limited_len) =
+				stack_limited_mod_len(gm_host_fn_module);
+
+			let (_gm_mg_sl_module, gas_metered_mut_glob_then_stack_limited_len) =
+				stack_limited_mod_len(gm_mut_global_module);
+
+			InstrumentedWasmResults {
+				filename,
+				original_module_len,
+				stack_limited_len,
+				gas_metered_host_fn_len,
+				gas_metered_mut_glob_len,
+				gas_metered_host_fn_then_stack_limited_len,
+				gas_metered_mut_glob_then_stack_limited_len,
+			}
+		})
+		.collect()
+}
+
+fn calc_size_overheads() -> Vec<InstrumentedWasmResults> {
+	let mut wasm_path = fixture_dir();
+	wasm_path.push("wasm");
+
+	let mut wat_path = fixture_dir();
+	wat_path.push("wat");
+
+	let mut results = size_overheads_all(read_dir(wasm_path).unwrap());
+	let results_wat = size_overheads_all(read_dir(wat_path).unwrap());
+
+	results.extend(results_wat);
+
+	results
+}
+
+/// Print the overhead of applying gas metering, stack
+/// height limiting or both.
+///
+/// Use `cargo test print_size_overhead -- --nocapture`.
+#[test]
+fn print_size_overhead() {
+	let mut results = calc_size_overheads();
+	results.sort_unstable_by(|a, b| {
+		b.gas_metered_mut_glob_then_stack_limited_len
+			.cmp(&a.gas_metered_mut_glob_then_stack_limited_len)
+	});
+
+	for r in results {
+		let filename = r.filename;
+		let original_size = r.original_module_len / 1024;
+		let stack_limit = r.stack_limited_len * 100 / r.original_module_len;
+		let host_fn = r.gas_metered_host_fn_len * 100 / r.original_module_len;
+		let mut_glob = r.gas_metered_mut_glob_len * 100 / r.original_module_len;
+		let host_fn_sl = r.gas_metered_host_fn_then_stack_limited_len * 100 / r.original_module_len;
+		let mut_glob_sl =
+			r.gas_metered_mut_glob_then_stack_limited_len * 100 / r.original_module_len;
+
+		println!(
+			"{filename:30}: orig = {original_size:4} kb, stack_limiter = {stack_limit} %, \
+			  gas_metered_host_fn =    {host_fn} %, both = {host_fn_sl} %,\n \
+			 {:69} gas_metered_mut_global = {mut_glob} %, both = {mut_glob_sl} %",
+			""
+		);
+	}
+}
+
+/// Compare module size overhead of applying gas metering with two methods.
+///
+/// Use `cargo test print_gas_metered_sizes -- --nocapture`.
+#[test]
+fn print_gas_metered_sizes() {
+	let overheads = calc_size_overheads();
+	let mut results = overheads
+		.iter()
+		.map(|r| {
+			let diff = (r.gas_metered_mut_glob_len * 100 / r.gas_metered_host_fn_len) as i32 - 100;
+			(diff, r)
+		})
+		.collect::<Vec<(i32, &InstrumentedWasmResults)>>();
+	results.sort_unstable_by(|a, b| b.0.cmp(&a.0));
+
+	println!(
+		"| {:28} | {:^16} | gas metered/host fn | gas metered/mut global | size diff |",
+		"fixture", "original size",
+	);
+	println!("|{:-^30}|{:-^18}|{:-^21}|{:-^24}|{:-^11}|", "", "", "", "", "",);
+	for r in results {
+		let filename = &r.1.filename;
+		let original_size = &r.1.original_module_len / 1024;
+		let host_fn = &r.1.gas_metered_host_fn_len / 1024;
+		let mut_glob = &r.1.gas_metered_mut_glob_len / 1024;
+		let host_fn_percent = &r.1.gas_metered_host_fn_len * 100 / r.1.original_module_len;
+		let mut_glob_percent = &r.1.gas_metered_mut_glob_len * 100 / r.1.original_module_len;
+		let host_fn = format!("{host_fn} kb ({host_fn_percent:}%)");
+		let mut_glob = format!("{mut_glob} kb ({mut_glob_percent:}%)");
+		let diff = &r.0;
+		println!(
+			"| {filename:28} | {original_size:13} kb | {host_fn:>19} | {mut_glob:>22} | {diff:+8}% |"
+		);
+	}
+}