Merge remote-tracking branch 'origin/main' into dani/compiler-improvements

Author: DaniPopes

crates/revmc-backend/src/traits.rs

@@ -153,6 +153,9 @@ pub enum Attribute {
     ArgMemOnly,
     /// `initializes((0, N))` — function initializes bytes `[0, N)` through this pointer.
     Initializes(u64),
+    /// `dead_on_return` — the contents of the pointed-to memory are dead after the function
+    /// returns, allowing the caller to elide stores to the memory.
+    DeadOnReturn,
     // TODO: Range?
 }
 

crates/revmc-cli/src/cmd/run.rs

@@ -82,6 +82,12 @@ pub(crate) struct RunArgs {
     /// Inspect the stack after the function has been executed.
     #[arg(long)]
     inspect_stack: bool,
+    /// Disable frame pointers in the JIT'd function. Frees up `rbp` for the
+    /// register allocator (15 GPRs instead of 14 on x86_64) at the cost of
+    /// not having `rbp`-based stack walks. DWARF `.eh_frame` unwinding still
+    /// works.
+    #[arg(long)]
+    no_frame_pointers: bool,
     #[arg(long, default_value = "1000000000")]
     gas_limit: u64,
 }
@@ -161,6 +167,9 @@ impl RunArgs {
             }
 
             compiler.inspect_stack(self.inspect_stack);
+            if self.no_frame_pointers {
+                compiler.frame_pointers(false);
+            }
 
             let parsed = compiler.parse(bytecode.as_slice().into(), compile_spec_id)?;
             if self.display || self.parse_only {

crates/revmc-codegen/src/bytecode/mod.rs

@@ -563,6 +563,12 @@ impl<'a> Bytecode<'a> {
         self.may_suspend
     }
 
+    /// Returns `true` if the stack argument's contents are observed by the caller after the
+    /// function returns (either through `inspect_stack` mode or because execution may suspend).
+    pub(crate) fn stack_observed(&self) -> bool {
+        self.config.contains(AnalysisConfig::INSPECT_STACK) || self.may_suspend()
+    }
+
     /// Returns `true` if any dead-block redirects exist.
     pub(crate) fn has_redirects(&self) -> bool {
         !self.redirects.is_empty()

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

@@ -585,7 +585,8 @@ impl<B: Backend> EvmCompiler<B> {
         }
 
         let linkage = Linkage::Public;
-        let (bcx, id) = Self::make_builder(&mut self.backend, &self.config, name, linkage)?;
+        let (bcx, id) =
+            Self::make_builder(&mut self.backend, &self.config, bytecode, name, linkage)?;
         FunctionCx::translate(bcx, self.config, &mut self.builtins, bytecode)?;
         Ok(id)
     }
@@ -653,6 +654,7 @@ impl<B: Backend> EvmCompiler<B> {
     fn make_builder<'a>(
         backend: &'a mut B,
         config: &FcxConfig,
+        bytecode: &Bytecode<'_>,
         name: &str,
         linkage: Linkage,
     ) -> Result<(B::Builder<'a>, B::FuncId)> {
@@ -687,6 +689,18 @@ impl<B: Backend> EvmCompiler<B> {
             }
         }
 
+        // The stack argument's contents are dead after return when the stack is not observed,
+        // so the caller can elide any stores to the buffer.
+        if !bytecode.stack_observed() {
+            for param in 1..=2 {
+                bcx.add_function_attribute(
+                    None,
+                    Attribute::DeadOnReturn,
+                    FunctionAttributeLocation::Param(param),
+                );
+            }
+        }
+
         Ok((bcx, id))
     }
 

crates/revmc-llvm/src/lib.rs

@@ -2084,6 +2084,7 @@ fn convert_attribute(bcx: &EvmLlvmBuilder<'_>, attr: revmc_backend::Attribute) -
         OurAttr::Writable => ("writable", AttrValue::Enum(0)),
         // memory(argmem: readwrite) = ModRef(3) << ArgMem(0) = 3.
         OurAttr::ArgMemOnly => ("memory", AttrValue::Enum(3)),
+        OurAttr::DeadOnReturn => ("dead_on_return", AttrValue::Enum(0)),
 
         OurAttr::Initializes(size) => {
             return cpp::create_initializes_attr(bcx.cx, 0, size as i64);