fix: resolve merge conflicts with memory IR

Author: DaniPopes

crates/revmc-codegen/src/compiler/translate/mod.rs

@@ -1893,13 +1893,14 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
         self.bytecode.op_block_name(self.current_inst, name)
     }
 
-    /// Converts a 256-bit unsigned integer to a 64-bit unsigned integer, saturating at `u64::MAX`.
+    /// Converts a 256-bit unsigned integer to a 64-bit unsigned integer, saturating at
+    /// `2^bits - 1`.
     fn u256_to_u64_saturating(&mut self, value: B::Value, bits: usize) -> B::Value {
         let i64_type = self.bcx.type_int(64);
         let reduced = self.bcx.ireduce(i64_type, value);
-        let extended = self.bcx.zext(self.word_type, reduced);
-        let fits = self.bcx.icmp(IntCC::Equal, value, extended);
         let sentinel_lit = 1u128.checked_shl(bits as u32).unwrap_or(0).wrapping_sub(1);
+        let sentinel_u256 = self.bcx.iconst_256(U256::from(sentinel_lit));
+        let fits = self.bcx.icmp(IntCC::UnsignedLessThanOrEqual, value, sentinel_u256);
         let sentinel = self.bcx.iconst(i64_type, sentinel_lit as i64);
         self.bcx.select(fits, reduced, sentinel)
     }

crates/revmc-codegen/src/compiler/translate/peephole.rs

@@ -250,37 +250,6 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
         }
     }
 
-    fn peephole_mstore(&mut self) -> bool {
-        let [offset, value] = self.const_operands();
-        let offset = offset.and_then(|x| u64::try_from(x).ok());
-        let value = value.and_then(|x| u64::try_from(x).ok());
-        match (offset, value) {
-            (Some(offset), None) => {
-                let offset = self.bcx.iconst(self.isize_type, offset as i64);
-                let sp = self.sp_after_inputs_with(&[1]);
-                self.call_fallible_builtin(Builtin::MstoreCD, &[self.ecx, offset, sp]);
-                true
-            }
-            (None, Some(value)) => {
-                let value = self.bcx.iconst(self.isize_type, value as i64);
-                let _ = self.sp_after_inputs_with(&[0]);
-                let sp = self.sp_from_top(1);
-                self.call_fallible_builtin(Builtin::MstoreDC, &[self.ecx, sp, value]);
-                true
-            }
-            (Some(offset), Some(value)) => {
-                // Both operands constant; consume from virtual stack.
-                self.pop_ignore(2);
-                let offset = self.bcx.iconst(self.isize_type, offset as i64);
-                let value = self.bcx.iconst(self.isize_type, value as i64);
-                self.call_fallible_builtin(Builtin::MstoreCC, &[self.ecx, offset, value]);
-                true
-            }
-            (None, None) => false,
-        }
-    }
-
-
     fn peephole_keccak256(&mut self) -> bool {
         if let Some((offset, len)) = self.const_memory_operands(self.const_operands()) {
             let offset = self.bcx.iconst(self.isize_type, offset as i64);