feat(evm): add EIP-7939 CLZ opcode (0x1e)

actors/evm/src/interpreter/execution.rs

@@ -125,6 +125,7 @@ pub mod opcodes {
         0x1b: SHL,
         0x1c: SHR,
         0x1d: SAR,
+        0x1e: CLZ,
         0x20: KECCAK256,
         0x30: ADDRESS,
         0x31: BALANCE,
@@ -292,6 +293,11 @@ pub fn execute(
 mod tests {
     use crate::evm_unit_test;
 
+    #[test]
+    fn test_clz_opcode_value() {
+        assert_eq!(super::opcodes::CLZ, 0x1e);
+    }
+
     macro_rules! check_underflow_err {
         ($($ins:ident,)*) => {
             $(do_check_underflow_err!($ins);)*
@@ -415,6 +421,7 @@ mod tests {
             CODECOPY,
             CREATE,
             CREATE2,
+            CLZ,
             RETURN,
             REVERT,
             SELFDESTRUCT,

actors/evm/src/interpreter/instructions/bitwise.rs

@@ -43,9 +43,81 @@ pub fn sar(shift: U256, mut value: U256) -> U256 {
     }
 }
 
+#[inline]
+pub fn clz(value: U256) -> U256 {
+    U256::from(value.leading_zeros())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::interpreter::opcodes;
+    use crate::interpreter::{execution::Machine, system::System, Output};
+    use crate::{Bytecode, EthAddress, ExecutionState};
+    use fil_actors_runtime::test_utils::MockRuntime;
+    use fvm_shared::econ::TokenAmount;
+
+    #[test]
+    fn test_clz_eip7939_vectors_unit() {
+        // Directly matches the EIP-7939 test cases.
+        assert_eq!(clz(U256::ZERO), U256::from(256));
+        assert_eq!(clz(U256::ONE << 255), U256::ZERO);
+        assert_eq!(clz(U256::MAX), U256::ZERO);
+        assert_eq!(clz(U256::ONE << 254), U256::ONE);
+        assert_eq!(clz((U256::ONE << 255) - U256::ONE), U256::ONE);
+        assert_eq!(clz(U256::ONE), U256::from(255));
+    }
+
+    #[test]
+    fn test_clz_misc_unit() {
+        // 2 is 10 binary, so 256 - 2 = 254
+        assert_eq!(clz(U256::from(2)), U256::from(254));
+    }
+
+    fn clz_via_evm(value: U256) -> U256 {
+        let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
+        let mut state = ExecutionState::new(
+            EthAddress::from_id(1000),
+            EthAddress::from_id(1000),
+            TokenAmount::from_atto(0),
+            Vec::new(),
+        );
+
+        let mut imm = [0u8; 32];
+        value.write_as_big_endian(&mut imm);
+
+        let mut code = Vec::with_capacity(1 + 32 + 1);
+        code.push(opcodes::PUSH32);
+        code.extend_from_slice(&imm);
+        code.push(opcodes::CLZ);
+
+        let mut system = System::new(&rt, false);
+        let bytecode = Bytecode::new(code);
+        let mut machine = Machine {
+            system: &mut system,
+            state: &mut state,
+            bytecode: &bytecode,
+            pc: 0,
+            output: Output::default(),
+        };
+
+        machine.step().expect("PUSH32 step failed");
+        machine.step().expect("CLZ step failed");
+        machine.state.stack.pop_many::<1>().expect("missing CLZ result")[0]
+    }
+
+    #[test]
+    fn test_clz_eip7939_vectors() {
+        // From EIP-7939 test cases.
+        assert_eq!(clz_via_evm(U256::ZERO), U256::from(256));
+        assert_eq!(clz_via_evm(U256::ONE << 255), U256::ZERO);
+        assert_eq!(clz_via_evm(U256::MAX), U256::ZERO);
+        assert_eq!(clz_via_evm(U256::ONE << 254), U256::ONE);
+        assert_eq!(clz_via_evm((U256::ONE << 255) - U256::ONE), U256::ONE);
+        assert_eq!(clz_via_evm(U256::ONE), U256::from(255));
+    }
 
     #[test]
     fn test_shl() {

actors/evm/src/interpreter/instructions/mod.rs

@@ -238,6 +238,7 @@ def_primop! { BYTE(a, b) => bitwise::byte }
 def_primop! { SHL(a, b) => bitwise::shl }
 def_primop! { SHR(a, b) => bitwise::shr }
 def_primop! { SAR(a, b) => bitwise::sar }
+def_primop! { CLZ(a) => bitwise::clz }
 // dup
 def_stackop! { DUP1 => stack::dup::<1> }
 def_stackop! { DUP2 => stack::dup::<2> }

actors/evm/tests/eip7939_clz.rs

@@ -0,0 +1,89 @@
+use fil_actor_evm::interpreter::opcodes;
+use fil_actors_evm_shared::uints::U256;
+
+mod util;
+
+fn initcode_for_runtime(runtime: &[u8]) -> Vec<u8> {
+    let len: u16 = runtime.len().try_into().expect("runtime too large");
+
+    // initcode:
+    // PUSH2 len
+    // PUSH2 offset
+    // PUSH1 0x00
+    // CODECOPY
+    // PUSH2 len
+    // PUSH1 0x00
+    // RETURN
+    // <runtime bytes>
+    let init_len: u16 = 15;
+    let offset = init_len;
+
+    let [len_hi, len_lo] = len.to_be_bytes();
+    let [off_hi, off_lo] = offset.to_be_bytes();
+
+    let mut code = vec![
+        opcodes::PUSH2,
+        len_hi,
+        len_lo,
+        opcodes::PUSH2,
+        off_hi,
+        off_lo,
+        opcodes::PUSH1,
+        0x00,
+        opcodes::CODECOPY,
+        opcodes::PUSH2,
+        len_hi,
+        len_lo,
+        opcodes::PUSH1,
+        0x00,
+        opcodes::RETURN,
+    ];
+    code.extend_from_slice(runtime);
+    code
+}
+
+fn clz_runtime() -> Vec<u8> {
+    // Reads a 32-byte word from calldata[0..32], computes CLZ, and returns the 32-byte result.
+    vec![
+        opcodes::PUSH1,
+        0x00,
+        opcodes::CALLDATALOAD,
+        opcodes::CLZ,
+        opcodes::PUSH1,
+        0x00,
+        opcodes::MSTORE,
+        opcodes::PUSH1,
+        0x20,
+        opcodes::PUSH1,
+        0x00,
+        opcodes::RETURN,
+    ]
+}
+
+fn u256_be_bytes(value: U256) -> [u8; 32] {
+    let mut out = [0u8; 32];
+    value.write_as_big_endian(&mut out);
+    out
+}
+
+#[test]
+fn eip7939_clz_vectors_end_to_end() {
+    let initcode = initcode_for_runtime(&clz_runtime());
+    let rt = util::construct_and_verify(initcode);
+
+    let vectors = [
+        (U256::ZERO, U256::from(256)),
+        (U256::ONE << 255, U256::ZERO),
+        (U256::MAX, U256::ZERO),
+        (U256::ONE << 254, U256::ONE),
+        ((U256::ONE << 255) - U256::ONE, U256::ONE),
+        (U256::ONE, U256::from(255)),
+    ];
+
+    for (input, expected) in vectors {
+        let ret = util::invoke_contract(&rt, &u256_be_bytes(input));
+        assert_eq!(ret.len(), 32);
+        assert_eq!(ret.as_slice(), &u256_be_bytes(expected));
+    }
+}
+