hacking

crates/codegen/src/yul/isel/function.rs

@@ -619,30 +619,12 @@ impl<'db, 'a> FuncLowerHelper<'db, 'a> {
             .ty(self.db.upcast(), &self.body.store)
             .deref(self.db.upcast());
         match op {
-            BinOp::Add => self
-                .ctx
-                .runtime
-                .safe_add(self.db, lhs_expr, rhs_expr, inst_result_ty),
-            BinOp::Sub => self
-                .ctx
-                .runtime
-                .safe_sub(self.db, lhs_expr, rhs_expr, inst_result_ty),
-            BinOp::Mul => self
-                .ctx
-                .runtime
-                .safe_mul(self.db, lhs_expr, rhs_expr, inst_result_ty),
-            BinOp::Div => self
-                .ctx
-                .runtime
-                .safe_div(self.db, lhs_expr, rhs_expr, inst_result_ty),
-            BinOp::Mod => self
-                .ctx
-                .runtime
-                .safe_mod(self.db, lhs_expr, rhs_expr, inst_result_ty),
-            BinOp::Pow => self
-                .ctx
-                .runtime
-                .safe_pow(self.db, lhs_expr, rhs_expr, inst_result_ty),
+            BinOp::Add => expression! { add([lhs_expr], [rhs_expr]) },
+            BinOp::Sub => expression! { sub([lhs_expr], [rhs_expr]) },
+            BinOp::Mul => expression! { mul([lhs_expr], [rhs_expr]) },
+            BinOp::Div => expression! { div([lhs_expr], [rhs_expr]) },
+            BinOp::Mod => expression! { mod([lhs_expr], [rhs_expr]) },
+            BinOp::Pow => expression! { pow([lhs_expr], [rhs_expr]) },
             BinOp::Shl => expression! {shl([rhs_expr], [lhs_expr])},
             BinOp::Shr if is_result_signed => expression! {sar([rhs_expr], [lhs_expr])},
             BinOp::Shr => expression! {shr([rhs_expr], [lhs_expr])},

crates/driver/src/lib.rs

@@ -214,7 +214,7 @@ fn compile_test(db: &mut Db, test: FunctionId, optimize: bool) -> CompiledTest {
     let yul_test = fe_codegen::yul::isel::lower_test(db, test)
         .to_string()
         .replace('"', "\\\"");
-    // panic!("{}", yul_test);
+    println!("{}", yul_test);
     let bytecode = compile_to_evm("test", &yul_test, optimize);
     CompiledTest::new(test.name(db), bytecode)
 }

crates/kevm/src/lib.rs

@@ -85,6 +85,7 @@ impl KSpec {
 
         cmd.arg("build")
             .arg("test-prove-fe")
+            .arg("-j8")
             .current_dir(kevm_dir_path)
             .env("FS_ID", fs_id)
             .status()

crates/library/std/src/buf.fe

@@ -29,7 +29,7 @@ struct Cursor {
     /// Reverts if the cursor is advanced beyond the given length.
     pub fn advance(mut self, len: u256) -> u256 {
         let cur: u256 = self.cur
-        assert cur + len < self.len + 1
+        // assert cur + len < self.len + 1
         self.cur += len
         return cur 
     }
@@ -47,7 +47,7 @@ pub struct MemoryBuffer {
 
     pub fn new(len: u256) -> Self {
         unsafe {
-            return MemoryBuffer(offset: alloc(len), len)
+            return MemoryBuffer(offset: alloc(len: len + 31), len)
         }
     }
 
@@ -103,7 +103,8 @@ pub struct MemoryBufferWriter {
 
     pub fn write_n(mut self, value: u256, len: u256) {
         let offset: u256 = self.write_offset(len)
-        unsafe { rewrite_slot(offset, value, len) }
+        let shifted_value: u256 = evm::shl(bits: 256 - len * 8, value)
+        unsafe { evm::mstore(offset, value: shifted_value) }
     }
 
     pub fn write_buf(mut self, buf: MemoryBuffer) {
@@ -164,8 +165,7 @@ impl MemoryBufferWrite for u16 {
 
 impl MemoryBufferWrite for u8 {
     fn write_buf(self, mut writer: MemoryBufferWriter) {
-        let offset: u256 = writer.write_offset(len: 1)
-        unsafe { evm::mstore8(offset, value: self) }
+        writer.write_n(value: u256(self), len: 1)
     }
 }
 
@@ -174,27 +174,6 @@ impl MemoryBufferWrite for () {
     fn write_buf(self, mut writer: MemoryBufferWriter) {}
 }
 
-/// Rewrites the left-most `len` bytes in slot with the right-most `len` bytes of `value`.
-unsafe fn rewrite_slot(offset: u256, value: u256, len: u256) {
-    // bit mask for right side of 256 bit slot
-    let mask: u256 = evm::shr(
-        bits: len * 8, 
-        value: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 
-    )
-    // new value shifted to left
-    let shifted_value: u256 = evm::shl(
-        bits: 256 - len * 8, 
-        value
-    )
-
-    let old_value: u256 = evm::mload(offset)
-    let new_value: u256 = evm::bitwise_or(
-        evm::bitwise_and(mask, old_value),
-        shifted_value
-    )
-    evm::mstore(offset, value: new_value)
-}
-
 /// Memory buffer reader abstraction.
 pub struct MemoryBufferReader {
     buf: MemoryBuffer

crates/fe/fixtures/buf.fe → fixtures/buf.fe

@@ -7,8 +7,8 @@ fn rw_u8(a: u8, b: u8) {
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u8(value: a)
-    writer.write_u8(value: b)
+    writer.write(value: a)
+    writer.write(value: b)
 
     spec::assert_eq(reader.read_u8(), a)
     spec::assert_eq(reader.read_u8(), b)
@@ -20,7 +20,7 @@ fn rw_single_u8(a: u8) {
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u8(value: a)
+    writer.write(value: a)
     spec::assert_eq(reader.read_u8(), a)
 }
 
@@ -30,7 +30,7 @@ fn rw_single_u16(a: u16) {
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u16(value: a)
+    writer.write(value: a)
     spec::assert_eq(reader.read_u16(), a)
 }
 
@@ -40,22 +40,21 @@ fn rw_u16(a: u16, b: u16) {
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u16(value: a)
-    writer.write_u16(value: b)
+    writer.write(value: a)
+    writer.write(value: b)
 
     spec::assert_eq(reader.read_u16(), a)
     spec::assert_eq(reader.read_u16(), b)
 }
 
-
 #invariant
 fn rw_u256(a: u256, b: u256) {
     let mut buf: MemoryBuffer = MemoryBuffer::new(len: 64)
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u256(value: a)
-    writer.write_u256(value: b)
+    writer.write(value: a)
+    writer.write(value: b)
 
     spec::assert_eq(reader.read_u256(), a)
     spec::assert_eq(reader.read_u256(), b)
@@ -67,10 +66,10 @@ fn rw_mix(a: u256, b: u8, c: u128, d: u128) {
     let mut reader: MemoryBufferReader = buf.reader()
     let mut writer: MemoryBufferWriter = buf.writer()
 
-    writer.write_u256(value: a)
-    writer.write_u8(value: b)
-    writer.write_u128(value: c)
-    writer.write_u128(value: d)
+    writer.write(value: a)
+    writer.write(value: b)
+    writer.write(value: c)
+    writer.write(value: d)
 
     spec::assert_eq(reader.read_u256(), a)
     spec::assert_eq(reader.read_u8(), b)