From 3ec2d307e5302f30a658fb25c37d19f49574ce33 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 7 Jul 2022 16:53:06 +0200 Subject: [PATCH 1/6] EVM interpreter --- evm/src/cpu/kernel/interpreter.rs | 287 ++++++++++++++++++++++++++++++ evm/src/cpu/kernel/mod.rs | 3 + 2 files changed, 290 insertions(+) create mode 100644 evm/src/cpu/kernel/interpreter.rs diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs new file mode 100644 index 00000000..f344befd --- /dev/null +++ b/evm/src/cpu/kernel/interpreter.rs @@ -0,0 +1,287 @@ +use ethereum_types::{U256, U512}; + +struct Interpreter { + code: Vec, + offset: usize, + stack: Vec, +} + +pub fn run(code: Vec, initial_offset: usize, initial_stack: Vec) -> Vec { + let mut interpreter = Interpreter { + code, + offset: initial_offset, + stack: initial_stack, + }; + while interpreter.offset < interpreter.code.len() { + interpreter.run_opcode(); + } + interpreter.stack +} + +impl Interpreter { + fn slice(&self, n: usize) -> &[u8] { + &self.code[self.offset..self.offset + n] + } + + fn incr(&mut self, n: usize) { + self.offset += n; + } + + fn push(&mut self, x: U256) { + self.stack.push(x); + } + + fn pop(&mut self) -> U256 { + self.stack.pop().expect("Pop on empty stack.") + } + + fn run_opcode(&mut self) { + let opcode = self.code[self.offset]; + self.incr(1); + match opcode { + 0x00 => todo!(), // "STOP", + 0x01 => self.run_add(), // "ADD", + 0x02 => self.run_mul(), // "MUL", + 0x03 => self.run_sub(), // "SUB", + 0x05 => todo!(), // "SDIV", + 0x06 => self.run_mod(), // "MOD", + 0x07 => todo!(), // "SMOD", + 0x08 => self.run_addmod(), // "ADDMOD", + 0x09 => self.run_mulmod(), // "MULMOD", + 0x0a => self.run_exp(), // "EXP", + 0x0b => todo!(), // "SIGNEXTEND", + 0x10 => self.run_lt(), // "LT", + 0x11 => self.run_gt(), // "GT", + 0x12 => todo!(), // "SLT", + 0x13 => todo!(), // "SGT", + 0x14 => self.run_eq(), // "EQ", + 0x15 => self.run_iszero(), // "ISZERO", + 0x16 => self.run_and(), // "AND", + 0x17 => self.run_or(), // "OR", + 0x18 => self.run_xor(), // "XOR", + 0x19 => self.run_not(), // "NOT", + 0x1a => todo!(), // "BYTE", + 0x1b => todo!(), // "SHL", + 0x1c => todo!(), // "SHR", + 0x1d => todo!(), // "SAR", + 0x20 => todo!(), // "KECCAK256", + 0x30 => todo!(), // "ADDRESS", + 0x31 => todo!(), // "BALANCE", + 0x32 => todo!(), // "ORIGIN", + 0x33 => todo!(), // "CALLER", + 0x34 => todo!(), // "CALLVALUE", + 0x35 => todo!(), // "CALLDATALOAD", + 0x36 => todo!(), // "CALLDATASIZE", + 0x37 => todo!(), // "CALLDATACOPY", + 0x38 => todo!(), // "CODESIZE", + 0x39 => todo!(), // "CODECOPY", + 0x3a => todo!(), // "GASPRICE", + 0x3b => todo!(), // "EXTCODESIZE", + 0x3c => todo!(), // "EXTCODECOPY", + 0x3d => todo!(), // "RETURNDATASIZE", + 0x3e => todo!(), // "RETURNDATACOPY", + 0x3f => todo!(), // "EXTCODEHASH", + 0x40 => todo!(), // "BLOCKHASH", + 0x41 => todo!(), // "COINBASE", + 0x42 => todo!(), // "TIMESTAMP", + 0x43 => todo!(), // "NUMBER", + 0x44 => todo!(), // "DIFFICULTY", + 0x45 => todo!(), // "GASLIMIT", + 0x46 => todo!(), // "CHAINID", + 0x48 => todo!(), // "BASEFEE", + 0x50 => todo!(), // "POP", + 0x51 => todo!(), // "MLOAD", + 0x52 => todo!(), // "MSTORE", + 0x53 => todo!(), // "MSTORE8", + 0x54 => todo!(), // "SLOAD", + 0x55 => todo!(), // "SSTORE", + 0x56 => self.run_jump(), // "JUMP", + 0x57 => self.run_jumpi(), // "JUMPI", + 0x58 => todo!(), // "GETPC", + 0x59 => todo!(), // "MSIZE", + 0x5a => todo!(), // "GAS", + 0x5b => self.incr(1), // "JUMPDEST", + x if (0x60..0x80).contains(&x) => self.run_push(x - 0x5f), // "PUSH" + x if (0x80..0x90).contains(&x) => self.run_dup(x - 0x7f), // "DUP" + x if (0x90..0xa0).contains(&x) => self.run_swap(x - 0x8f), // "SWAP" + 0xa0 => todo!(), // "LOG0", + 0xa1 => todo!(), // "LOG1", + 0xa2 => todo!(), // "LOG2", + 0xa3 => todo!(), // "LOG3", + 0xa4 => todo!(), // "LOG4", + 0xf0 => todo!(), // "CREATE", + 0xf1 => todo!(), // "CALL", + 0xf2 => todo!(), // "CALLCODE", + 0xf3 => todo!(), // "RETURN", + 0xf4 => todo!(), // "DELEGATECALL", + 0xf5 => todo!(), // "CREATE2", + 0xfa => todo!(), // "STATICCALL", + 0xfd => todo!(), // "REVERT", + 0xfe => todo!(), // "INVALID", + 0xff => todo!(), // "SELFDESTRUCT", + _ => panic!("Unrecognized mnemonic."), + }; + } + + fn run_add(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x + y); + self.incr(1); + } + + fn run_mul(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x * y); + self.incr(1); + } + + fn run_sub(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x - y); + self.incr(1); + } + + fn run_mod(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x % y); + self.incr(1); + } + + fn run_addmod(&mut self) { + let x = U512::from(self.pop()); + let y = U512::from(self.pop()); + let z = U512::from(self.pop()); + let res = (x + y) % z; + self.push(U256([0, 1, 2, 3].map(|i| res.0[i]))); + self.incr(1); + } + + fn run_mulmod(&mut self) { + let x = self.pop(); + let y = self.pop(); + let z = U512::from(self.pop()); + let res = x.full_mul(y) % z; + self.push(U256([0, 1, 2, 3].map(|i| res.0[i]))); + self.incr(1); + } + + fn run_exp(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x.pow(y)); + self.incr(1); + } + + fn run_lt(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(if x < y { U256::one() } else { U256::zero() }); + self.incr(1); + } + + fn run_gt(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(if x > y { U256::one() } else { U256::zero() }); + self.incr(1); + } + + fn run_eq(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(if x == y { U256::one() } else { U256::zero() }); + self.incr(1); + } + + fn run_iszero(&mut self) { + let x = self.pop(); + self.push(if x.is_zero() { + U256::one() + } else { + U256::zero() + }); + self.incr(1); + } + + fn run_and(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x & y); + self.incr(1); + } + + fn run_or(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x | y); + self.incr(1); + } + + fn run_xor(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x ^ y); + self.incr(1); + } + + fn run_not(&mut self) { + let x = self.pop(); + self.push(!x); + self.incr(1); + } + + fn run_jump(&mut self) { + let x = self.pop().as_usize(); + self.offset = x; + assert_eq!( + self.code[self.offset], 0x5b, + "Destination is not a JUMPDEST." + ); + } + + fn run_jumpi(&mut self) { + let x = self.pop().as_usize(); + let b = self.pop(); + if !b.is_zero() { + self.offset = x; + assert_eq!( + self.code[self.offset], 0x5b, + "Destination is not a JUMPDEST." + ); + } else { + self.incr(1); + } + } + + fn run_push(&mut self, num_bytes: u8) { + let x = U256::from_big_endian(self.slice(num_bytes as usize)); + self.incr(num_bytes as usize); + self.push(x); + } + + fn run_dup(&mut self, n: u8) { + self.push(self.stack[n as usize - 1]); + self.incr(1); + } + + fn run_swap(&mut self, n: u8) { + self.stack.swap(0, n as usize); + self.incr(1); + } +} + +#[cfg(test)] +mod tests { + use crate::cpu::kernel::interpreter::run; + + #[test] + fn test_run() { + // PUSH1 1 PUSH1 2 ADD + let code = vec![0x60, 0x1, 0x60, 0x2, 0x1]; + assert_eq!(run(code, 0, vec![]), vec![0x3.into()]); + } +} diff --git a/evm/src/cpu/kernel/mod.rs b/evm/src/cpu/kernel/mod.rs index 4dcf9a6c..3e565d98 100644 --- a/evm/src/cpu/kernel/mod.rs +++ b/evm/src/cpu/kernel/mod.rs @@ -4,6 +4,9 @@ mod ast; mod opcodes; mod parser; +#[cfg(test)] +mod interpreter; + use assembler::assemble; use parser::parse; From 9c4947e0f0663eb7bc5801482e3bfac4bb094d43 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 7 Jul 2022 18:06:24 +0200 Subject: [PATCH 2/6] EC ops test --- evm/src/cpu/kernel/aggregator.rs | 138 ++++++++++++++++++++++++++++++ evm/src/cpu/kernel/assembler.rs | 2 +- evm/src/cpu/kernel/interpreter.rs | 48 +++++++---- 3 files changed, 169 insertions(+), 19 deletions(-) diff --git a/evm/src/cpu/kernel/aggregator.rs b/evm/src/cpu/kernel/aggregator.rs index ac0d6f7c..d58208fd 100644 --- a/evm/src/cpu/kernel/aggregator.rs +++ b/evm/src/cpu/kernel/aggregator.rs @@ -23,11 +23,149 @@ pub(crate) fn combined_kernel() -> Kernel { #[cfg(test)] mod tests { + use std::str::FromStr; + + use anyhow::Result; + use ethereum_types::U256; + use crate::cpu::kernel::aggregator::combined_kernel; + use crate::cpu::kernel::interpreter::run; #[test] fn make_kernel() { // Make sure we can parse and assemble the entire kernel. combined_kernel(); } + + fn u256ify<'a>(hexes: impl IntoIterator) -> Result> { + Ok(hexes + .into_iter() + .map(U256::from_str) + .collect::, _>>()?) + } + + #[test] + fn test_ec_ops() -> Result<()> { + // Make sure we can parse and assemble the entire kernel. + let kernel = combined_kernel(); + let ec_add = kernel.global_labels["ec_add"]; + let ec_double = kernel.global_labels["ec_double"]; + let ec_mul = kernel.global_labels["ec_mul"]; + let identity = ("0x0", "0x0"); + let invalid = ("0x0", "0x3"); // Not on curve + let point0 = ( + "0x1feee7ec986e198890cb83be8b8ba09ee953b3f149db6d9bfdaa5c308a33e58d", + "0x2051cc9a9edd46231604fd88f351e95ec72a285be93e289ac59cb48561efb2c6", + ); + let point1 = ( + "0x15b64d0a5f329fb672029298be8050f444626e6de11903caffa74b388075be1b", + "0x2d9e07340bd5cd7b70687b98f2500ff930a89a30d7b6a3e04b1b4d345319d234", + ); + // point2 = point0 + point1 + let point2 = ( + "0x18659c0e0a8fedcb8747cf463fc7cfa05f667d84e771d0a9521fc1a550688f0c", + "0x283ed10b42703e187e7a808aeb45c6b457bc4cc7d704e53b3348a1e3b0bfa55b", + ); + // point3 = 2 * point0 + let point3 = ( + "0x17da2b7b1a01c8dfdf0f5a6415833c7d755d219aa7e2c4cd0ac83d87d0ca4217", + "0xc9ace9de14aac8114541b50c19320eb40f0eeac3621526d9e34dbcf4c3a6c0f", + ); + let s = "0xabb2a34c0e7956cfe6cef9ddb7e810c45ea19a6ebadd79c21959af09f5ba480a"; + // point4 = s * point0 + let point4 = ( + "0xe519344959cc17021fe98878f947f5c1b1675325533a620c1684cfa6367e6c0", + "0x7496a7575b0b6a821e19ce780ecc3e0b156e605327798693defeb9f265b7a6f", + ); + + // Standard addition #1 + let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point2.1, point2.0])?); + // Standard addition #2 + let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point2.1, point2.0])?); + + // Standard doubling #1 + let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point3.1, point3.0])?); + // Standard doubling #2 + let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?; + let stack = run(&kernel.code, ec_double, initial_stack); + assert_eq!(stack, u256ify([point3.1, point3.0])?); + // Standard doubling #3 + let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, u256ify([point3.1, point3.0])?); + + // Addition with identity #1 + let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point1.1, point1.0])?); + // Addition with identity #2 + let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point1.1, point1.0])?); + // Addition with identity #3 + let initial_stack = + u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([identity.1, identity.0])?); + + // Addition with invalid point(s) #1 + let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, invalid.1, invalid.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, vec![U256::MAX, U256::MAX]); + // Addition with invalid point(s) #2 + let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, point0.1, point0.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, vec![U256::MAX, U256::MAX]); + // Addition with invalid point(s) #3 + let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, identity.1, identity.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, vec![U256::MAX, U256::MAX]); + // Addition with invalid point(s) #4 + let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, invalid.1, invalid.0])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, vec![U256::MAX, U256::MAX]); + + // Scalar multiplication #1 + let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, u256ify([point4.1, point4.0])?); + // Scalar multiplication #2 + let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, u256ify([identity.1, identity.0])?); + // Scalar multiplication #3 + let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, u256ify([point0.1, point0.0])?); + // Scalar multiplication #4 + let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, u256ify([identity.1, identity.0])?); + // Scalar multiplication #5 + let initial_stack = u256ify(["0xdeadbeef", s, invalid.1, invalid.0])?; + let stack = run(&kernel.code, ec_mul, initial_stack); + assert_eq!(stack, vec![U256::MAX, U256::MAX]); + + // Multiple calls + let ec_mul_hex = format!("0x{:x}", ec_mul); + let initial_stack = u256ify([ + "0xdeadbeef", + s, + &ec_mul_hex, + identity.1, + identity.0, + point0.1, + point0.0, + ])?; + let stack = run(&kernel.code, ec_add, initial_stack); + assert_eq!(stack, u256ify([point4.1, point4.0])?); + + Ok(()) + } } diff --git a/evm/src/cpu/kernel/assembler.rs b/evm/src/cpu/kernel/assembler.rs index d7e40f24..91f64a42 100644 --- a/evm/src/cpu/kernel/assembler.rs +++ b/evm/src/cpu/kernel/assembler.rs @@ -16,7 +16,7 @@ const BYTES_PER_OFFSET: u8 = 3; #[derive(PartialEq, Eq, Debug)] pub struct Kernel { pub code: Vec, - global_labels: HashMap, + pub(crate) global_labels: HashMap, } pub(crate) fn assemble(files: Vec) -> Kernel { diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index f344befd..c1f69108 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -1,12 +1,12 @@ use ethereum_types::{U256, U512}; -struct Interpreter { - code: Vec, +struct Interpreter<'a> { + code: &'a [u8], offset: usize, stack: Vec, } -pub fn run(code: Vec, initial_offset: usize, initial_stack: Vec) -> Vec { +pub fn run(code: &[u8], initial_offset: usize, initial_stack: Vec) -> Vec { let mut interpreter = Interpreter { code, offset: initial_offset, @@ -18,7 +18,7 @@ pub fn run(code: Vec, initial_offset: usize, initial_stack: Vec) -> Ve interpreter.stack } -impl Interpreter { +impl<'a> Interpreter<'a> { fn slice(&self, n: usize) -> &[u8] { &self.code[self.offset..self.offset + n] } @@ -37,12 +37,12 @@ impl Interpreter { fn run_opcode(&mut self) { let opcode = self.code[self.offset]; - self.incr(1); match opcode { 0x00 => todo!(), // "STOP", 0x01 => self.run_add(), // "ADD", 0x02 => self.run_mul(), // "MUL", 0x03 => self.run_sub(), // "SUB", + 0x04 => self.run_div(), // "DIV", 0x05 => todo!(), // "SDIV", 0x06 => self.run_mod(), // "MOD", 0x07 => todo!(), // "SMOD", @@ -89,7 +89,7 @@ impl Interpreter { 0x45 => todo!(), // "GASLIMIT", 0x46 => todo!(), // "CHAINID", 0x48 => todo!(), // "BASEFEE", - 0x50 => todo!(), // "POP", + 0x50 => self.run_pop(), // "POP", 0x51 => todo!(), // "MLOAD", 0x52 => todo!(), // "MSTORE", 0x53 => todo!(), // "MSTORE8", @@ -119,7 +119,7 @@ impl Interpreter { 0xfd => todo!(), // "REVERT", 0xfe => todo!(), // "INVALID", 0xff => todo!(), // "SELFDESTRUCT", - _ => panic!("Unrecognized mnemonic."), + _ => panic!("Unrecognized opcode {}.", opcode), }; } @@ -144,6 +144,13 @@ impl Interpreter { self.incr(1); } + fn run_div(&mut self) { + let x = self.pop(); + let y = self.pop(); + self.push(x / y); + self.incr(1); + } + fn run_mod(&mut self) { let x = self.pop(); let y = self.pop(); @@ -234,13 +241,17 @@ impl Interpreter { self.incr(1); } + fn run_pop(&mut self) { + self.pop(); + self.incr(1); + } + fn run_jump(&mut self) { let x = self.pop().as_usize(); self.offset = x; - assert_eq!( - self.code[self.offset], 0x5b, - "Destination is not a JUMPDEST." - ); + if let Some(&landing_opcode) = self.code.get(self.offset) { + assert_eq!(landing_opcode, 0x5b, "Destination is not a JUMPDEST."); + } } fn run_jumpi(&mut self) { @@ -248,28 +259,29 @@ impl Interpreter { let b = self.pop(); if !b.is_zero() { self.offset = x; - assert_eq!( - self.code[self.offset], 0x5b, - "Destination is not a JUMPDEST." - ); + if let Some(&landing_opcode) = self.code.get(self.offset) { + assert_eq!(landing_opcode, 0x5b, "Destination is not a JUMPDEST."); + } } else { self.incr(1); } } fn run_push(&mut self, num_bytes: u8) { + self.incr(1); let x = U256::from_big_endian(self.slice(num_bytes as usize)); self.incr(num_bytes as usize); self.push(x); } fn run_dup(&mut self, n: u8) { - self.push(self.stack[n as usize - 1]); + self.push(self.stack[self.stack.len() - n as usize]); self.incr(1); } fn run_swap(&mut self, n: u8) { - self.stack.swap(0, n as usize); + let len = self.stack.len(); + self.stack.swap(len - 1, len - n as usize - 1); self.incr(1); } } @@ -282,6 +294,6 @@ mod tests { fn test_run() { // PUSH1 1 PUSH1 2 ADD let code = vec![0x60, 0x1, 0x60, 0x2, 0x1]; - assert_eq!(run(code, 0, vec![]), vec![0x3.into()]); + assert_eq!(run(&code, 0, vec![]), vec![0x3.into()]); } } From 267f4162dd67b0375131e71357783b3a98557191 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 7 Jul 2022 18:20:24 +0200 Subject: [PATCH 3/6] Minor --- evm/src/cpu/kernel/interpreter.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index c1f69108..29245fc9 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -12,7 +12,8 @@ pub fn run(code: &[u8], initial_offset: usize, initial_stack: Vec) -> Vec< offset: initial_offset, stack: initial_stack, }; - while interpreter.offset < interpreter.code.len() { + // Halt the execution if a jump to 0xdeadbeef was done. + while interpreter.offset != 0xdeadbeef { interpreter.run_opcode(); } interpreter.stack From f8987b7e80cd9b1e60806889d5adeef03bc4e48e Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 7 Jul 2022 18:20:24 +0200 Subject: [PATCH 4/6] Minor --- evm/src/cpu/kernel/interpreter.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index c1f69108..a099a48b 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -12,7 +12,8 @@ pub fn run(code: &[u8], initial_offset: usize, initial_stack: Vec) -> Vec< offset: initial_offset, stack: initial_stack, }; - while interpreter.offset < interpreter.code.len() { + // Halt the execution if a jump to 0xdeadbeef was done. + while interpreter.offset != 0xdeadbeef { interpreter.run_opcode(); } interpreter.stack @@ -292,8 +293,9 @@ mod tests { #[test] fn test_run() { - // PUSH1 1 PUSH1 2 ADD - let code = vec![0x60, 0x1, 0x60, 0x2, 0x1]; + let code = vec![ + 0x60, 0x1, 0x60, 0x2, 0x1, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56, + ]; // PUSH1, 1, PUSH1, 2, ADD, PUSH4 deadbeef, JUMP assert_eq!(run(&code, 0, vec![]), vec![0x3.into()]); } } From 7bf5118f69b1f36392c8e8865b44892a42af1fc0 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 7 Jul 2022 18:46:20 +0200 Subject: [PATCH 5/6] Test exp kernel function --- evm/src/cpu/kernel/aggregator.rs | 36 +++++++++++++++++++++++++++++++ evm/src/cpu/kernel/asm/exp.asm | 3 +++ evm/src/cpu/kernel/interpreter.rs | 8 +++---- 3 files changed, 43 insertions(+), 4 deletions(-) diff --git a/evm/src/cpu/kernel/aggregator.rs b/evm/src/cpu/kernel/aggregator.rs index d58208fd..a23e18b8 100644 --- a/evm/src/cpu/kernel/aggregator.rs +++ b/evm/src/cpu/kernel/aggregator.rs @@ -27,6 +27,7 @@ mod tests { use anyhow::Result; use ethereum_types::U256; + use rand::{thread_rng, Rng}; use crate::cpu::kernel::aggregator::combined_kernel; use crate::cpu::kernel::interpreter::run; @@ -43,6 +44,41 @@ mod tests { .map(U256::from_str) .collect::, _>>()?) } + #[test] + fn test_exp() -> Result<()> { + // Make sure we can parse and assemble the entire kernel. + let kernel = combined_kernel(); + let exp = kernel.global_labels["exp"]; + let mut rng = thread_rng(); + let a = U256([0; 4].map(|_| rng.gen())); + let b = U256([0; 4].map(|_| rng.gen())); + + // Random input + let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, a]; + let stack_with_kernel = run(&kernel.code, exp, initial_stack); + let initial_stack = vec![b, a]; + let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP + let stack_with_opcode = run(&code, 0, initial_stack); + assert_eq!(stack_with_kernel, stack_with_opcode); + + // 0 base + let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, U256::zero()]; + let stack_with_kernel = run(&kernel.code, exp, initial_stack); + let initial_stack = vec![b, U256::zero()]; + let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP + let stack_with_opcode = run(&code, 0, initial_stack); + assert_eq!(stack_with_kernel, stack_with_opcode); + + // 0 exponent + let initial_stack = vec![U256::from_str("0xdeadbeef")?, U256::zero(), a]; + let stack_with_kernel = run(&kernel.code, exp, initial_stack); + let initial_stack = vec![U256::zero(), a]; + let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP + let stack_with_opcode = run(&code, 0, initial_stack); + assert_eq!(stack_with_kernel, stack_with_opcode); + + Ok(()) + } #[test] fn test_ec_ops() -> Result<()> { diff --git a/evm/src/cpu/kernel/asm/exp.asm b/evm/src/cpu/kernel/asm/exp.asm index 3e3b0f6f..683e67c3 100644 --- a/evm/src/cpu/kernel/asm/exp.asm +++ b/evm/src/cpu/kernel/asm/exp.asm @@ -10,6 +10,7 @@ /// Note that this correctly handles exp(0, 0) == 1. global exp: + jumpdest // stack: x, e, retdest dup2 // stack: e, x, e, retdest @@ -28,6 +29,7 @@ global exp: jump step_case: + jumpdest // stack: x, e, retdest push recursion_return // stack: recursion_return, x, e, retdest @@ -45,6 +47,7 @@ step_case: // stack: exp, x * x, e / 2, recursion_return, x, e, retdest jump recursion_return: + jumpdest // stack: exp(x * x, e / 2), x, e, retdest push 2 // stack: 2, exp(x * x, e / 2), x, e, retdest diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index a099a48b..97fb5209 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -127,21 +127,21 @@ impl<'a> Interpreter<'a> { fn run_add(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x + y); + self.push(x.overflowing_add(y).0); self.incr(1); } fn run_mul(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x * y); + self.push(x.overflowing_mul(y).0); self.incr(1); } fn run_sub(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x - y); + self.push(x.overflowing_sub(y).0); self.incr(1); } @@ -180,7 +180,7 @@ impl<'a> Interpreter<'a> { fn run_exp(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x.pow(y)); + self.push(x.overflowing_pow(y).0); self.incr(1); } From 12ca084620c1d1371336c612d7511dea85e2ed1c Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 8 Jul 2022 09:58:52 +0200 Subject: [PATCH 6/6] PR feedback --- evm/src/cpu/kernel/interpreter.rs | 59 ++++++++++++------------------- 1 file changed, 22 insertions(+), 37 deletions(-) diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index 97fb5209..500d4a8e 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -32,12 +32,17 @@ impl<'a> Interpreter<'a> { self.stack.push(x); } + fn push_bool(&mut self, x: bool) { + self.stack.push(if x { U256::one() } else { U256::zero() }); + } + fn pop(&mut self) -> U256 { self.stack.pop().expect("Pop on empty stack.") } fn run_opcode(&mut self) { let opcode = self.code[self.offset]; + self.incr(1); match opcode { 0x00 => todo!(), // "STOP", 0x01 => self.run_add(), // "ADD", @@ -101,7 +106,7 @@ impl<'a> Interpreter<'a> { 0x58 => todo!(), // "GETPC", 0x59 => todo!(), // "MSIZE", 0x5a => todo!(), // "GAS", - 0x5b => self.incr(1), // "JUMPDEST", + 0x5b => (), // "JUMPDEST", x if (0x60..0x80).contains(&x) => self.run_push(x - 0x5f), // "PUSH" x if (0x80..0x90).contains(&x) => self.run_dup(x - 0x7f), // "DUP" x if (0x90..0xa0).contains(&x) => self.run_swap(x - 0x8f), // "SWAP" @@ -128,123 +133,108 @@ impl<'a> Interpreter<'a> { let x = self.pop(); let y = self.pop(); self.push(x.overflowing_add(y).0); - self.incr(1); } fn run_mul(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x.overflowing_mul(y).0); - self.incr(1); } fn run_sub(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x.overflowing_sub(y).0); - self.incr(1); } fn run_div(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x / y); - self.incr(1); + self.push(if y.is_zero() { U256::zero() } else { x / y }); } fn run_mod(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(x % y); - self.incr(1); + self.push(if y.is_zero() { U256::zero() } else { x % y }); } fn run_addmod(&mut self) { let x = U512::from(self.pop()); let y = U512::from(self.pop()); let z = U512::from(self.pop()); - let res = (x + y) % z; - self.push(U256([0, 1, 2, 3].map(|i| res.0[i]))); - self.incr(1); + self.push(if z.is_zero() { + U256::zero() + } else { + U256::try_from((x + y) % z).unwrap() + }); } fn run_mulmod(&mut self) { let x = self.pop(); let y = self.pop(); let z = U512::from(self.pop()); - let res = x.full_mul(y) % z; - self.push(U256([0, 1, 2, 3].map(|i| res.0[i]))); - self.incr(1); + self.push(if z.is_zero() { + U256::zero() + } else { + U256::try_from(x.full_mul(y) % z).unwrap() + }); } fn run_exp(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x.overflowing_pow(y).0); - self.incr(1); } fn run_lt(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(if x < y { U256::one() } else { U256::zero() }); - self.incr(1); + self.push_bool(x < y); } fn run_gt(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(if x > y { U256::one() } else { U256::zero() }); - self.incr(1); + self.push_bool(x > y); } fn run_eq(&mut self) { let x = self.pop(); let y = self.pop(); - self.push(if x == y { U256::one() } else { U256::zero() }); - self.incr(1); + self.push_bool(x == y); } fn run_iszero(&mut self) { let x = self.pop(); - self.push(if x.is_zero() { - U256::one() - } else { - U256::zero() - }); - self.incr(1); + self.push_bool(x.is_zero()); } fn run_and(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x & y); - self.incr(1); } fn run_or(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x | y); - self.incr(1); } fn run_xor(&mut self) { let x = self.pop(); let y = self.pop(); self.push(x ^ y); - self.incr(1); } fn run_not(&mut self) { let x = self.pop(); self.push(!x); - self.incr(1); } fn run_pop(&mut self) { self.pop(); - self.incr(1); } fn run_jump(&mut self) { @@ -263,13 +253,10 @@ impl<'a> Interpreter<'a> { if let Some(&landing_opcode) = self.code.get(self.offset) { assert_eq!(landing_opcode, 0x5b, "Destination is not a JUMPDEST."); } - } else { - self.incr(1); } } fn run_push(&mut self, num_bytes: u8) { - self.incr(1); let x = U256::from_big_endian(self.slice(num_bytes as usize)); self.incr(num_bytes as usize); self.push(x); @@ -277,13 +264,11 @@ impl<'a> Interpreter<'a> { fn run_dup(&mut self, n: u8) { self.push(self.stack[self.stack.len() - n as usize]); - self.incr(1); } fn run_swap(&mut self, n: u8) { let len = self.stack.len(); self.stack.swap(len - 1, len - n as usize - 1); - self.incr(1); } }