WIP: Known values

Cargo.toml

@@ -22,7 +22,9 @@ codegen-units = 1
 
 [dependencies]
 parity-wasm = { version = "0.45", default-features = false }
-log = "0.4"
+log = { version = "0.4.8", default-features = false, optional = true }
+test-log = { version = "0.2", optional = true }
+env_logger = { version = "0.9", optional = true }
 
 [dev-dependencies]
 binaryen = "0.12"
@@ -30,10 +32,11 @@ criterion = "0.3"
 diff = "0.1"
 rand = "0.8"
 wat = "1"
-wasmparser = "0.88"
+wasmparser = "0.87"
 wasmprinter = "0.2"
 
 [features]
 default = ["std"]
 std = ["parity-wasm/std"]
 sign_ext = ["parity-wasm/sign_ext"]
+trace-log = ["dep:log", "dep:test-log", "dep:env_logger"]

src/lib.rs

@@ -1,8 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 extern crate alloc;
-#[macro_use]
-extern crate log;
 
 mod export_globals;
 pub mod gas_metering;
@@ -10,4 +8,6 @@ mod stack_limiter;
 
 pub use export_globals::export_mutable_globals;
 pub use parity_wasm;
-pub use stack_limiter::{compute_stack_cost, inject as inject_stack_limiter};
+pub use stack_limiter::{
+	compute_stack_cost, compute_stack_height_weight, inject as inject_stack_limiter,
+};

src/stack_limiter/mod.rs

@@ -6,7 +6,6 @@ use parity_wasm::{
 	builder,
 	elements::{self, Instruction, Instructions, Type},
 };
-pub use max_height::StackHeightStats;
 
 /// Macro to generate preamble and postamble.
 macro_rules! instrument_call {
@@ -41,7 +40,7 @@ mod thunk;
 
 pub struct Context {
 	stack_height_global_idx: u32,
-	func_stack_costs: Vec<StackHeightStats>,
+	func_stack_costs: Vec<u32>,
 	stack_limit: u32,
 }
 
@@ -53,11 +52,7 @@ impl Context {
 
 	/// Returns `stack_cost` for `func_idx`.
 	fn stack_cost(&self, func_idx: u32) -> Option<u32> {
-		if let Some(stats) = self.func_stack_costs.get(func_idx as usize) {
-			Some(stats.total_cost)
-		} else {
-			None
-		}
+		self.func_stack_costs.get(func_idx as usize).cloned()
 	}
 
 	/// Returns stack limit specified by the rules.
@@ -159,7 +154,7 @@ fn generate_stack_height_global(module: &mut elements::Module) -> u32 {
 /// 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<StackHeightStats>, &'static str> {
+pub fn compute_stack_costs(module: &elements::Module) -> Result<Vec<u32>, &'static str> {
 	let func_imports = module.import_count(elements::ImportCountType::Function);
 
 	// TODO: optimize!
@@ -167,7 +162,7 @@ fn compute_stack_costs(module: &elements::Module) -> Result<Vec<StackHeightStats
 		.map(|func_idx| {
 			if func_idx < func_imports {
 				// We can't calculate stack_cost of the import functions.
-				Ok(Default::default())
+				Ok(0)
 			} else {
 				compute_stack_cost(func_idx as u32, module)
 			}
@@ -178,7 +173,7 @@ fn compute_stack_costs(module: &elements::Module) -> Result<Vec<StackHeightStats
 /// 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.
-pub fn compute_stack_cost(func_idx: u32, module: &elements::Module) -> Result<StackHeightStats, &'static str> {
+pub 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;
@@ -186,6 +181,37 @@ pub fn compute_stack_cost(func_idx: u32, module: &elements::Module) -> Result<St
 		.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_stack_weight) = 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")
+}
+
+/// Stack height is the measurement maximum wasm stack height reached during function execution.
+/// Stack weight is weighted value which approximates a real stack size on x64 architecture.
+pub fn compute_stack_height_weight(
+	func_idx: u32,
+	module: &elements::Module,
+) -> Result<(u32, u32), &'static str> {
+	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")?;
+
 	max_height::compute(defined_func_idx, module)
 }