chore: update revm gas

crates/revm-jit-builtins/src/utils.rs

@@ -23,15 +23,10 @@ pub(crate) fn resize_memory(
 ) -> InstructionResult {
     let size = offset.saturating_add(len);
     if size > ecx.memory.len() {
-        let rounded_size = revm_interpreter::interpreter::next_multiple_of_32(size);
-
         // TODO: Memory limit
-
-        // TODO: try_resize
-        if !ecx.gas.record_memory(rgas::memory_gas(rounded_size / 32)) {
-            return InstructionResult::MemoryLimitOOG;
+        if !revm_interpreter::interpreter::resize_memory(ecx.memory, ecx.gas, size) {
+            return InstructionResult::MemoryOOG;
         }
-        ecx.memory.resize(rounded_size);
     }
     InstructionResult::Continue
 }

crates/revm-jit/src/bytecode/mod.rs

@@ -335,6 +335,14 @@ impl<'a> Bytecode<'a> {
         false
     }
 
+    /// Returns `true` if the bytecode is small.
+    ///
+    /// This is arbitarily chosen to speed up compilation for larger contracts.
+    #[allow(dead_code)]
+    pub(crate) fn is_small(&self) -> bool {
+        self.insts.len() < 2000
+    }
+
     /// Returns `true` if the instruction is diverging.
     pub(crate) fn is_instr_diverging(&self, inst: Inst) -> bool {
         self.insts[inst].is_diverging(self.is_eof())

crates/revm-jit/src/compiler/translate.rs

@@ -65,8 +65,6 @@ pub(super) struct FunctionCx<'a, B: Backend> {
     stack: Pointer<B::Builder<'a>>,
     /// The amount of gas remaining. `i64`. See `Gas`.
     gas_remaining: Pointer<B::Builder<'a>>,
-    /// The amount of gas remaining, without accounting for memory expansion. `i64`. See `Gas`.
-    gas_remaining_nomem: Pointer<B::Builder<'a>>,
     /// The environment. Constant throughout the function.
     env: B::Value,
     /// The contract. Constant throughout the function.
@@ -186,11 +184,6 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
             let name = "gas.remaining.addr";
             Pointer::new_address(i64_type, bcx.gep(i8_type, gas_ptr, &[offset], name))
         };
-        let gas_remaining_nomem = {
-            let offset = bcx.iconst(i64_type, mem::offset_of!(pf::Gas, remaining_nomem) as i64);
-            let name = "gas.remaining_nomem.addr";
-            Pointer::new_address(i64_type, bcx.gep(i8_type, gas_ptr, &[offset], name))
-        };
 
         let sp_arg = bcx.fn_param(1);
         let stack = if config.local_stack {
@@ -236,7 +229,6 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
             stack_len,
             stack,
             gas_remaining,
-            gas_remaining_nomem,
             env,
             contract,
             ecx,
@@ -1325,18 +1317,19 @@ impl<'a, B: Backend> FunctionCx<'a, B> {
         }
 
         // Modified from `Gas::record_cost`.
-        // Group operations to allow for vectorization.
         // This can overflow the gas counters, which has to be adjusted for after the call.
         let gas_remaining = self.load_gas_remaining();
-        let nomem = self.gas_remaining_nomem.load(&mut self.bcx, "gas_remaining_nomem");
-
         let (res, overflow) = self.bcx.usub_overflow(gas_remaining, cost);
-        let nomem = self.bcx.isub(nomem, cost);
-
-        self.store_gas_remaining(res);
-        self.gas_remaining_nomem.store(&mut self.bcx, nomem);
-
-        self.build_check(overflow, InstructionResult::OutOfGas);
+        if self.bytecode.is_small() {
+            // Storing the result before the check significantly increases time spent in
+            // `llvm::MemoryDependenceResults::getNonLocalPointerDependency`, but it might produce
+            // slightly better code.
+            self.store_gas_remaining(res);
+            self.build_check(overflow, InstructionResult::OutOfGas);
+        } else {
+            self.build_check(overflow, InstructionResult::OutOfGas);
+            self.store_gas_remaining(res);
+        }
     }
 
     /*
@@ -1540,6 +1533,7 @@ mod pf {
         data: AtomicPtr<()>,
         vtable: &'static Vtable,
     }
+    const _: [(); mem::size_of::<revm_primitives::Bytes>()] = [(); mem::size_of::<Bytes>()];
     struct Vtable {
         /// fn(data, ptr, len)
         clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
@@ -1562,13 +1556,10 @@ mod pf {
         pub(super) limit: u64,
         /// The remaining gas.
         pub(super) remaining: u64,
-        /// The remaining gas, without memory expansion.
-        pub(super) remaining_nomem: u64,
-        /// The **last** memory expansion cost.
-        memory: u64,
         /// Refunded gas. This is used only at the end of execution.
         refunded: i64,
     }
+    const _: [(); mem::size_of::<revm_interpreter::Gas>()] = [(); mem::size_of::<Gas>()];
 }
 
 fn op_block_name_with(op: Inst, data: &InstData, with: &str) -> String {

crates/revm-jit/src/tests/mod.rs

@@ -826,8 +826,7 @@ tests! {
                     output: Bytes::copy_from_slice(&0x69_U256.to_be_bytes::<32>()),
                     gas: {
                         let mut gas = Gas::new(DEF_GAS_LIMIT);
-                        assert!(gas.record_cost(3 + 2 + 3 + 3 + 2));
-                        assert!(gas.record_memory(gas::memory_gas(1)));
+                        assert!(gas.record_cost(3 + 2 + (3 + gas::memory_gas(1)) + 3 + 2));
                         gas
                     },
                 },
@@ -844,8 +843,7 @@ tests! {
                     output: Bytes::copy_from_slice(&0x69_U256.to_be_bytes::<32>()),
                     gas: {
                         let mut gas = Gas::new(DEF_GAS_LIMIT);
-                        assert!(gas.record_cost(3 + 2 + 3 + 3 + 2));
-                        assert!(gas.record_memory(gas::memory_gas(1)));
+                        assert!(gas.record_cost(3 + 2 + (3 + gas::memory_gas(1)) + 3 + 2));
                         gas
                     },
                 },