From 62698bf998ea80fbaf1c8320348ce4a2d5d81882 Mon Sep 17 00:00:00 2001 From: mm Date: Fri, 24 May 2024 09:51:23 +0200 Subject: [PATCH 1/2] fixed far-call modifier and fixed tests --- src/assembly/instruction/far_call.rs | 6 ++++++ src/assembly/mnemonic/binop.rs | 4 ++-- src/assembly/mnemonic/context.rs | 2 +- src/assembly/mnemonic/log.rs | 2 +- src/assembly/mnemonic/set_flags.rs | 4 ++-- src/assembly/mnemonic/shift.rs | 2 +- src/assembly/mod.rs | 4 ++-- src/assembly/parse/addressing.rs | 12 ++++++++++++ 8 files changed, 27 insertions(+), 9 deletions(-) diff --git a/src/assembly/instruction/far_call.rs b/src/assembly/instruction/far_call.rs index f75979e..2c49a98 100644 --- a/src/assembly/instruction/far_call.rs +++ b/src/assembly/instruction/far_call.rs @@ -78,6 +78,12 @@ impl FarCall { } } } + if !modifiers.is_empty() { + return Err(InstructionReadError::UnknownArgument(format!( + "{:?}", + modifiers + ))); + } if result.is_none() { // our default behavior diff --git a/src/assembly/mnemonic/binop.rs b/src/assembly/mnemonic/binop.rs index a123a98..f2bac1a 100644 --- a/src/assembly/mnemonic/binop.rs +++ b/src/assembly/mnemonic/binop.rs @@ -69,14 +69,14 @@ mod test { #[test] fn test_parse_mov() { let example = "mov r2, r3"; - let r = parse_mov_combinator(example).simplify(); + let r = parse_mov_combinator(example).simplify().unwrap(); dbg!(r); } #[test] fn test_parse_xor() { let example = "xor.s.set_flags r2, r3, r0"; - let r = parse_xor_combinator(example).simplify(); + let r = parse_xor_combinator(example).simplify().unwrap(); dbg!(r); } } diff --git a/src/assembly/mnemonic/context.rs b/src/assembly/mnemonic/context.rs index f9a76aa..f96a339 100644 --- a/src/assembly/mnemonic/context.rs +++ b/src/assembly/mnemonic/context.rs @@ -32,7 +32,7 @@ mod test { #[test] fn test_parse_gas_left() { let example = "context.gas_left r1"; - let r = parse_gas_left_combinator(example).simplify(); + let r = parse_gas_left_combinator(example).simplify().unwrap(); dbg!(r); } } diff --git a/src/assembly/mnemonic/log.rs b/src/assembly/mnemonic/log.rs index 2fc33fa..db4ec56 100644 --- a/src/assembly/mnemonic/log.rs +++ b/src/assembly/mnemonic/log.rs @@ -60,7 +60,7 @@ mod test { #[test] fn test_parse_event() { let example = "event.first r6, r5"; - let r = parse_event_combinator(example).simplify(); + let r = parse_event_combinator(example).simplify().unwrap(); dbg!(r); } } diff --git a/src/assembly/mnemonic/set_flags.rs b/src/assembly/mnemonic/set_flags.rs index 9ff74f7..45c9739 100644 --- a/src/assembly/mnemonic/set_flags.rs +++ b/src/assembly/mnemonic/set_flags.rs @@ -15,14 +15,14 @@ mod test { #[test] fn test_canonicalize_set_flags() { let example = "add! r2, r3, r4"; - let r = parse_set_flags_combinator(example).simplify(); + let r = parse_set_flags_combinator(example).simplify().unwrap(); dbg!(r); } #[test] fn test_canonicalize_set_flags2() { let example = "sub.s! r2, r3, r4"; - let r = parse_set_flags_combinator(example).simplify(); + let r = parse_set_flags_combinator(example).simplify().unwrap(); dbg!(r); } } diff --git a/src/assembly/mnemonic/shift.rs b/src/assembly/mnemonic/shift.rs index 5267f31..3fe6038 100644 --- a/src/assembly/mnemonic/shift.rs +++ b/src/assembly/mnemonic/shift.rs @@ -60,7 +60,7 @@ mod test { #[test] fn test_parse_rol() { let example = "shl.s.set_flags r2, r3, r4"; - let r = parse_shl_combinator(example).simplify(); + let r = parse_shl_combinator(example).simplify().unwrap(); dbg!(r); } } diff --git a/src/assembly/mod.rs b/src/assembly/mod.rs index 955a64b..b8d7651 100644 --- a/src/assembly/mod.rs +++ b/src/assembly/mod.rs @@ -369,7 +369,7 @@ mod test { fn parse_full_assembly_line() { let asm = "sub.s r1, r2, r3"; - let res = try_parse_opcode_and_modifiers(asm); + let res = try_parse_opcode_and_modifiers(asm).unwrap(); dbg!(res); } @@ -417,7 +417,7 @@ __eh: fn test_parse_tmp() { let mut assembly = Assembly::try_from(TMP.to_owned()).unwrap(); let _ = assembly.compile_to_bytecode().unwrap(); - let instructions = assembly.opcodes::<8, EncodingModeProduction>(); + let instructions = assembly.opcodes::<8, EncodingModeProduction>().unwrap(); dbg!(&instructions); } } diff --git a/src/assembly/parse/addressing.rs b/src/assembly/parse/addressing.rs index d40feb4..1960a18 100644 --- a/src/assembly/parse/addressing.rs +++ b/src/assembly/parse/addressing.rs @@ -666,6 +666,18 @@ mod test { dbg!(operand); } + #[test] + fn test_far_call_with_invalid_modifiers() { + use crate::assembly::parse::code_element::parse_code_element; + + let error = + parse_code_element("far_call.foobar r2, r3, @.BB5_2").expect_err("Should have failed"); + assert!( + matches!(error, InstructionReadError::UnknownArgument(_)), + "Expected Uknown argument error" + ); + } + #[test] fn test_uma_imm() { use crate::assembly::parse::code_element::parse_code_element; From d8de3f2a1bb23c88066bc78164937cf329546c2c Mon Sep 17 00:00:00 2001 From: mm Date: Fri, 24 May 2024 10:00:59 +0200 Subject: [PATCH 2/2] Added support for static_read and static_write --- src/assembly/instruction/uma.rs | 11 ++++-- src/assembly/parse/addressing.rs | 58 ++++++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+), 2 deletions(-) diff --git a/src/assembly/instruction/uma.rs b/src/assembly/instruction/uma.rs index cc81900..7ed70be 100644 --- a/src/assembly/instruction/uma.rs +++ b/src/assembly/instruction/uma.rs @@ -30,17 +30,20 @@ pub struct UMA { } impl UMA { - pub const ALL_CANONICAL_MODIFIERS: [&'static str; 5] = [ + pub const ALL_CANONICAL_MODIFIERS: [&'static str; 7] = [ "heap_read", "heap_write", "aux_heap_read", "aux_heap_write", "fat_ptr_read", + "static_read", + "static_write", ]; pub const INCREMENT_OFFSET_MODIFIER: &'static str = "inc"; - pub const ALL_SHORTHARD_MODIFIERS: [&'static str; 5] = ["rh", "wh", "rah", "wah", "rptr"]; + pub const ALL_SHORTHARD_MODIFIERS: [&'static str; 7] = + ["rh", "wh", "rah", "wah", "rptr", "rs", "ws"]; #[track_caller] pub fn build_from_parts( @@ -80,6 +83,8 @@ impl UMA { 2 => UMAOpcode::AuxHeapRead, 3 => UMAOpcode::AuxHeapWrite, 4 => UMAOpcode::FatPointerRead, + 5 => UMAOpcode::StaticMemoryRead, + 6 => UMAOpcode::StaticMemoryWrite, _ => { unreachable!() } @@ -106,6 +111,8 @@ impl UMA { 2 => UMAOpcode::AuxHeapRead, 3 => UMAOpcode::AuxHeapWrite, 4 => UMAOpcode::FatPointerRead, + 5 => UMAOpcode::StaticMemoryRead, + 6 => UMAOpcode::StaticMemoryWrite, _ => { unreachable!() } diff --git a/src/assembly/parse/addressing.rs b/src/assembly/parse/addressing.rs index 1960a18..b7ec3d9 100644 --- a/src/assembly/parse/addressing.rs +++ b/src/assembly/parse/addressing.rs @@ -622,6 +622,8 @@ fn parse_immediate_value<'a>(input: &'a str) -> IResult<&str, u64> { #[cfg(test)] mod test { + use zkevm_opcode_defs::Opcode; + use super::*; #[test] @@ -702,5 +704,61 @@ mod test { dbg!(&operand); let opcode: DecodedOpcode<8, EncodingModeProduction> = operand.try_into().unwrap(); dbg!(&opcode); + + assert!( + matches!( + opcode.variant.opcode, + Opcode::UMA(zkevm_opcode_defs::UMAOpcode::HeapWrite) + ), + "wrong decode" + ); + } + + #[test] + fn test_uma_variants() { + use crate::assembly::parse::code_element::parse_code_element; + + let operand = parse_code_element("uma.static_read 123, r0, r1, r0").unwrap(); + let opcode: DecodedOpcode<8, EncodingModeProduction> = operand.try_into().unwrap(); + + assert!( + matches!( + opcode.variant.opcode, + Opcode::UMA(zkevm_opcode_defs::UMAOpcode::StaticMemoryRead) + ), + "wrong decode" + ); + + let operand = parse_code_element("uma.rs 123, r0, r1, r0").unwrap(); + let opcode: DecodedOpcode<8, EncodingModeProduction> = operand.try_into().unwrap(); + + assert!( + matches!( + opcode.variant.opcode, + Opcode::UMA(zkevm_opcode_defs::UMAOpcode::StaticMemoryRead) + ), + "wrong decode" + ); + + let operand = parse_code_element("uma.static_write r2, r0, r1, r0").unwrap(); + let opcode: DecodedOpcode<8, EncodingModeProduction> = operand.try_into().unwrap(); + assert!( + matches!( + opcode.variant.opcode, + Opcode::UMA(zkevm_opcode_defs::UMAOpcode::StaticMemoryWrite) + ), + "wrong decode" + ); + + let operand = parse_code_element("uma.ws 123, r0, r1, r0").unwrap(); + let opcode: DecodedOpcode<8, EncodingModeProduction> = operand.try_into().unwrap(); + + assert!( + matches!( + opcode.variant.opcode, + Opcode::UMA(zkevm_opcode_defs::UMAOpcode::StaticMemoryWrite) + ), + "wrong decode" + ); } }