Add ptr pack

lambdaclass · Jun 18, 2024 · ae120bd · ae120bd
1 parent 3fdf796
commit ae120bd
Show file tree

Hide file tree

Showing 6 changed files with 152 additions and 7 deletions.
diff --git a/programs/pack_ptr.zasm b/programs/pack_ptr.zasm
@@ -0,0 +1,13 @@
+	.text
+	.file	"add.zasm"
+	.globl	__entry
+__entry:
+.func_begin0:
+	; sets r1 and r2 from tests
+	ptr.pack	r1, r2, r3
+	sstore	r0, r3
+	ret
+.func_end0:
+
+	.note.GNU-stack
+	.rodata
diff --git a/src/lib.rs b/src/lib.rs
@@ -7,6 +7,7 @@ pub mod value;
 
 use op_handlers::add::_add;
 use op_handlers::ptr_add::_ptr_add;
+use op_handlers::ptr_pack::_ptr_pack;
 use op_handlers::ptr_shrink::_ptr_shrink;
 use op_handlers::ptr_sub::_ptr_sub;
 use op_handlers::sub::_sub;
@@ -65,7 +66,7 @@ pub fn run_program_with_custom_state(bin_path: &str, mut vm: VMState) -> (U256,
                 Variant::Ptr(ptr_variant) => match ptr_variant {
                     PtrOpcode::Add => _ptr_add(&mut vm, &opcode),
                     PtrOpcode::Sub => _ptr_sub(&mut vm, &opcode),
-                    PtrOpcode::Pack => todo!(),
+                    PtrOpcode::Pack => _ptr_pack(&mut vm, &opcode),
                     PtrOpcode::Shrink => _ptr_shrink(&mut vm, &opcode),
                 },
                 Variant::NearCall(_) => todo!(),

diff --git a/src/op_handlers/mod.rs b/src/op_handlers/mod.rs
@@ -2,4 +2,5 @@ pub mod add;
 pub mod ptr_add;
 pub mod ptr_sub;
 pub mod ptr_shrink;
+pub mod ptr_pack;
 pub mod sub;
diff --git a/src/op_handlers/ptr_pack.rs b/src/op_handlers/ptr_pack.rs
@@ -0,0 +1,20 @@
+use u256::U256;
+
+use crate::{
+    address_operands::{address_operands_read, address_operands_store}, state::VMState, value::TaggedValue, Opcode
+};
+
+pub fn _ptr_pack(vm: &mut VMState, opcode: &Opcode) {
+    let (src0, src1) = address_operands_read(vm, opcode);
+
+    if !src0.is_pointer || src1.is_pointer {
+        panic!("Invalid operands for ptr_pack");
+    }
+
+    if src1.value & U256::from_str_radix("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16).unwrap() != U256::zero() {
+        panic!("Src1 low 128 bits not 0");
+    }
+
+    let res = TaggedValue::new_pointer(((src0.value << 128) >> 128)| src1.value);
+    address_operands_store(vm, opcode, res)
+}
diff --git a/src/ptr_operator.rs b/src/ptr_operator.rs
@@ -13,6 +13,7 @@ pub fn ptr_operands_read(
     opcode_name: &str,
 ) -> (FatPointer, u32, TaggedValue) {
     let (src0, src1) = address_operands_read(vm, opcode);
+    println!("src0: {:?}, src1: {:?}", src0, src1);
 
     if !src0.is_pointer || src1.is_pointer {
         panic!("Invalid operands for {}", opcode_name);

diff --git a/tests/integration_test.rs b/tests/integration_test.rs
@@ -354,14 +354,14 @@ fn test_ptr_add_panics_if_src0_not_a_pointer() {
 #[test]
 #[should_panic = "Invalid operands for ptr_add"]
 fn test_ptr_add_panics_if_src1_is_a_pointer() {
-    let bin_path = make_bin_path_asm("add_ptr");
+    let bin_path = make_bin_path_asm("add_ptr_r2_set");
     let ptr = FatPointer {
         offset: (1 << 31) - 1,
         page: 0,
         start: 0,
         len: 0,
     };
-    let r1 = TaggedValue::new_raw_integer(U256::one());
+    let r1 = TaggedValue::new_pointer(ptr.encode());
     let r2 = TaggedValue::new_pointer(ptr.encode());
     let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
     registers[0] = r1;
@@ -437,14 +437,14 @@ fn test_ptr_sub_panics_if_src0_not_a_pointer() {
 #[test]
 #[should_panic = "Invalid operands for ptr_sub"]
 fn test_ptr_sub_panics_if_src1_is_a_pointer() {
-    let bin_path = make_bin_path_asm("sub_ptr");
+    let bin_path = make_bin_path_asm("sub_ptr_r2_set");
     let ptr = FatPointer {
         offset: (1 << 31) - 1,
         page: 0,
         start: 0,
         len: 0,
     };
-    let r1 = TaggedValue::new_raw_integer(U256::one());
+    let r1 = TaggedValue::new_pointer(ptr.encode());
     let r2 = TaggedValue::new_pointer(ptr.encode());
     let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
     registers[0] = r1;
@@ -547,14 +547,123 @@ fn test_ptr_shrink_panics_if_src0_not_a_pointer() {
 #[test]
 #[should_panic = "Invalid operands for ptr_shrink"]
 fn test_ptr_shrink_panics_if_src1_is_a_pointer() {
-    let bin_path = make_bin_path_asm("shrink_ptr");
+    let bin_path = make_bin_path_asm("shrink_ptr_r2_set");
     let ptr = FatPointer {
         offset: 0,
         page: 0,
         start: 0,
         len: (1 << 31) - 1,
     };
-    let r1 = TaggedValue::new_raw_integer(U256::one());
+    let r1 = TaggedValue::new_pointer(ptr.encode());
+    let r2 = TaggedValue::new_pointer(ptr.encode());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+}
+
+#[test]
+fn test_ptr_pack() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let ptr = FatPointer {
+        offset: 0,
+        page: 0,
+        start: 0,
+        len: 0,
+    };
+    let r1 = TaggedValue::new_pointer(ptr.encode());
+    let r2 = TaggedValue::new_raw_integer(U256::from_str_radix("0x100000000000000000000000000000000", 16).unwrap());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    let (result, _) = run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+    assert_eq!(result, U256::from_str_radix("0x100000000000000000000000000000000", 16).unwrap());
+}
+
+#[test]
+fn test_ptr_pack_max_value() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let ptr = FatPointer {
+        offset: 0,
+        page: 0,
+        start: 0,
+        len: 0,
+    };
+    let r1 = TaggedValue::new_pointer(ptr.encode());
+    let r2 = TaggedValue::new_raw_integer(U256::from_str_radix("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000", 16).unwrap());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    let (result, _) = run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+    assert_eq!(result, U256::from_str_radix("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000", 16).unwrap());
+}
+
+#[test]
+fn test_ptr_pack_pointer_not_empty() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let ptr = FatPointer {
+        offset: 0,
+        page: 0,
+        start: 0,
+        len: 10,
+    };
+    let r1 = TaggedValue::new_pointer(ptr.encode());
+    let r2 = TaggedValue::new_raw_integer(U256::from_str_radix("0x100000000000000000000000000000000", 16).unwrap());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    let (result, _) = run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+    let new_ptr = FatPointer::decode(result);
+    assert_eq!(new_ptr.len, 10);
+}
+
+#[test]
+#[should_panic = "Src1 low 128 bits not 0"]
+fn test_ptr_pack_diff_incorrect_value() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let ptr = FatPointer {
+        offset: 0,
+        page: 0,
+        start: 0,
+        len: 10,
+    };
+    let r1 = TaggedValue::new_pointer(ptr.encode());
+    let r2 = TaggedValue::new_raw_integer(U256::from_str_radix("0x100000000000000000000000000100000", 16).unwrap());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+}
+
+#[test]
+#[should_panic = "Invalid operands for ptr_pack"]
+fn test_ptr_pack_panics_if_src0_not_a_pointer() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let r1 = TaggedValue::new_raw_integer(U256::from(5));
+    let r2 = TaggedValue::new_raw_integer(U256::from_str_radix("0x100000000000000000000000000100000", 16).unwrap());
+    let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
+    registers[0] = r1;
+    registers[1] = r2;
+    let vm_with_custom_flags = VMState::new_with_registers(registers);
+    run_program_with_custom_state(&bin_path, vm_with_custom_flags);
+}
+
+#[test]
+#[should_panic = "Invalid operands for ptr_pack"]
+fn test_ptr_pack_panics_if_src1_is_a_pointer() {
+    let bin_path = make_bin_path_asm("pack_ptr");
+    let ptr = FatPointer {
+        offset: 0,
+        page: 0,
+        start: 0,
+        len: (1 << 31) - 1,
+    };
+    let r1 = TaggedValue::new_pointer(ptr.encode());
     let r2 = TaggedValue::new_pointer(ptr.encode());
     let mut registers: [TaggedValue; 15] = [TaggedValue::default(); 15];
     registers[0] = r1;