llvm-context: modularize compiler builtin functions (#234)

- Add the revive runtime function interface to minimize boiler plate code. - Outline heavily repeated code into dedicated functions to bring down code size. - The code size tests builds optimized for size. - Function attributes are passed as slices. This significantly brings down the code size for all OpenZeppelin wizard contracts (using all possible features) compiled against OpenZeppelin `v5.0.0` with size optimizations. |contract|| `-Oz` main | `-Oz` PR || `-O3` main | `-O3` PR | |-|-|-|-|-|-|-| |erc1155.sol||100K|67K||114K|147K| |erc20.sol||120K|90K||160K|191K| |erc721.sol||128K|101K||178K|214K| |governor.sol||226K|165K||293K|349K| |rwa.sol||116K|85K||154K|185K| |stable.sol||116K|86K||155K|192K| On the flip side this introduces a heavy penalty for cycle optimized builds. Setting the no-inline attributes for cycle optimized builds helps a lot but heavily penalizes runtime speed (LLVM does not yet inline everything properly - to be investigated later on). Next steps: - Modularize more functions - Refactor the YUL function arguments to use pointers instead of values - Afterwards check if LLVM still has trouble inline-ing properly on O3 or set the no-inline attribute if it does not penalize runtime performance too bad.
2026-06-15 08:01:09 +00:00 · 2025-02-25 16:47:01 +01:00
parent 7ffe64ed7c
commit a07968205b
32 changed files with 1444 additions and 655 deletions
@@ -2,8 +2,13 @@

 use inkwell::values::BasicValue;

+use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::PolkaVMDivisionFunction;
+use crate::PolkaVMRemainderFunction;
+use crate::PolkaVMSignedDivisionFunction;
+use crate::PolkaVMSignedRemainderFunction;

 /// Translates the arithmetic addition.
 pub fn addition<'ctx, D>(
@@ -59,11 +64,11 @@ pub fn division<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    wrapped_division(context, operand_2, || {
-        Ok(context
-            .builder()
-            .build_int_unsigned_div(operand_1, operand_2, "DIV")?)
-    })
+    let name = <PolkaVMDivisionFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMDivisionFunction as RuntimeFunction<D>>::declaration(context);
+    Ok(context
+        .build_call(declaration, &[operand_1.into(), operand_2.into()], "div")
+        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
 }

 /// Translates the arithmetic remainder.
@@ -75,11 +80,11 @@ pub fn remainder<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    wrapped_division(context, operand_2, || {
-        Ok(context
-            .builder()
-            .build_int_unsigned_rem(operand_1, operand_2, "MOD")?)
-    })
+    let name = <PolkaVMRemainderFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMRemainderFunction as RuntimeFunction<D>>::declaration(context);
+    Ok(context
+        .build_call(declaration, &[operand_1.into(), operand_2.into()], "rem")
+        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
 }

 /// Translates the signed arithmetic division.
@@ -94,54 +99,11 @@ pub fn division_signed<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    assert_eq!(
-        operand_2.get_type().get_bit_width(),
-        revive_common::BIT_LENGTH_WORD as u32
-    );
-
-    let block_calculate = context.append_basic_block("calculate");
-    let block_overflow = context.append_basic_block("overflow");
-    let block_select = context.append_basic_block("select_result");
-    let block_origin = context.basic_block();
-    context.builder().build_switch(
-        operand_2,
-        block_calculate,
-        &[
-            (context.word_type().const_zero(), block_select),
-            (context.word_type().const_all_ones(), block_overflow),
-        ],
-    )?;
-
-    context.set_basic_block(block_calculate);
-    let quotient = context
-        .builder()
-        .build_int_signed_div(operand_1, operand_2, "SDIV")?;
-    context.build_unconditional_branch(block_select);
-
-    context.set_basic_block(block_overflow);
-    let max_uint = context.builder().build_int_z_extend(
-        context
-            .integer_type(revive_common::BIT_LENGTH_WORD - 1)
-            .const_all_ones(),
-        context.word_type(),
-        "max_uint",
-    )?;
-    let is_operand_1_overflow = context.builder().build_int_compare(
-        inkwell::IntPredicate::EQ,
-        operand_1,
-        context.builder().build_int_neg(max_uint, "min_uint")?,
-        "is_operand_1_overflow",
-    )?;
-    context.build_conditional_branch(is_operand_1_overflow, block_select, block_calculate)?;
-
-    context.set_basic_block(block_select);
-    let result = context.builder().build_phi(context.word_type(), "result")?;
-    result.add_incoming(&[
-        (&operand_1, block_overflow),
-        (&context.word_const(0), block_origin),
-        (&quotient.as_basic_value_enum(), block_calculate),
-    ]);
-    Ok(result.as_basic_value())
+    let name = <PolkaVMSignedDivisionFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMSignedDivisionFunction as RuntimeFunction<D>>::declaration(context);
+    Ok(context
+        .build_call(declaration, &[operand_1.into(), operand_2.into()], "sdiv")
+        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
 }

 /// Translates the signed arithmetic remainder.
@@ -153,53 +115,9 @@ pub fn remainder_signed<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    wrapped_division(context, operand_2, || {
-        Ok(context
-            .builder()
-            .build_int_signed_rem(operand_1, operand_2, "SMOD")?)
-    })
-}
-
-/// Wrap division operations so that zero will be returned if the
-/// denominator is zero (see also Ethereum YP Appendix H.2).
-///
-/// The closure is expected to calculate and return the quotient.
-///
-/// The result is either the calculated quotient or zero,
-///  selected at runtime.
-fn wrapped_division<'ctx, D, F, T>(
-    context: &Context<'ctx, D>,
-    denominator: inkwell::values::IntValue<'ctx>,
-    f: F,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-    F: FnOnce() -> anyhow::Result<T>,
-    T: inkwell::values::IntMathValue<'ctx>,
-{
-    assert_eq!(
-        denominator.get_type().get_bit_width(),
-        revive_common::BIT_LENGTH_WORD as u32
-    );
-
-    let block_calculate = context.append_basic_block("calculate");
-    let block_select = context.append_basic_block("select");
-    let block_origin = context.basic_block();
-    context.builder().build_switch(
-        denominator,
-        block_calculate,
-        &[(context.word_const(0), block_select)],
-    )?;
-
-    context.set_basic_block(block_calculate);
-    let calculated_value = f()?.as_basic_value_enum();
-    context.build_unconditional_branch(block_select);
-
-    context.set_basic_block(block_select);
-    let result = context.builder().build_phi(context.word_type(), "result")?;
-    result.add_incoming(&[
-        (&context.word_const(0), block_origin),
-        (&calculated_value, block_calculate),
-    ]);
-    Ok(result.as_basic_value())
+    let name = <PolkaVMSignedRemainderFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMSignedRemainderFunction as RuntimeFunction<D>>::declaration(context);
+    Ok(context
+        .build_call(declaration, &[operand_1.into(), operand_2.into()], "srem")
+        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
 }
@@ -2,84 +2,183 @@

 use inkwell::values::BasicValue;

+use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::polkavm::WriteLLVM;
+
+/// A function for emitting EVM event logs from contract code.
+pub struct EventLog<const N: usize>;
+
+impl<D, const N: usize> RuntimeFunction<D> for EventLog<N>
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = match N {
+        0 => "__revive_log_0",
+        1 => "__revive_log_1",
+        2 => "__revive_log_2",
+        3 => "__revive_log_3",
+        4 => "__revive_log_4",
+        _ => unreachable!(),
+    };
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        let mut parameter_types = vec![context.xlen_type().into(), context.xlen_type().into()];
+        parameter_types.extend_from_slice(&[context.word_type().into(); N]);
+        context.void_type().fn_type(&parameter_types, false)
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
+        let input_offset = Self::paramater(context, 0).into_int_value();
+        let input_length = Self::paramater(context, 1).into_int_value();
+        let input_pointer = context.builder().build_ptr_to_int(
+            context.build_heap_gep(input_offset, input_length)?.value,
+            context.xlen_type(),
+            "event_input_offset",
+        )?;
+
+        let arguments = if N == 0 {
+            [
+                context.xlen_type().const_zero().as_basic_value_enum(),
+                context.xlen_type().const_zero().as_basic_value_enum(),
+                input_pointer.as_basic_value_enum(),
+                input_length.as_basic_value_enum(),
+            ]
+        } else {
+            let topics_buffer_size = N * revive_common::BYTE_LENGTH_WORD;
+            let topics_buffer_pointer = context.build_alloca_at_entry(
+                context.byte_type().array_type(topics_buffer_size as u32),
+                "topics_buffer",
+            );
+
+            for n in 0..N {
+                let topic = Self::paramater(context, n + 2);
+                let topic_buffer_offset = context
+                    .xlen_type()
+                    .const_int((n * revive_common::BYTE_LENGTH_WORD) as u64, false);
+                context.build_store(
+                    context.build_gep(
+                        topics_buffer_pointer,
+                        &[context.xlen_type().const_zero(), topic_buffer_offset],
+                        context.byte_type(),
+                        &format!("topic_buffer_{N}_gep"),
+                    ),
+                    context.build_byte_swap(topic.as_basic_value_enum())?,
+                )?;
+            }
+
+            [
+                context
+                    .builder()
+                    .build_ptr_to_int(
+                        topics_buffer_pointer.value,
+                        context.xlen_type(),
+                        "event_topics_offset",
+                    )?
+                    .as_basic_value_enum(),
+                context
+                    .xlen_type()
+                    .const_int(N as u64, false)
+                    .as_basic_value_enum(),
+                input_pointer.as_basic_value_enum(),
+                input_length.as_basic_value_enum(),
+            ]
+        };
+
+        context.build_runtime_call(
+            revive_runtime_api::polkavm_imports::DEPOSIT_EVENT,
+            &arguments,
+        );
+
+        Ok(None)
+    }
+}
+
+impl<D> WriteLLVM<D> for EventLog<0>
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+impl<D> WriteLLVM<D> for EventLog<1>
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+impl<D> WriteLLVM<D> for EventLog<2>
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+impl<D> WriteLLVM<D> for EventLog<3>
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+impl<D> WriteLLVM<D> for EventLog<4>
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}

 /// Translates a log or event call.
-///
-/// TODO: Splitting up into dedicated functions (log0..log4)
-/// could potentially decrease code sizes (LLVM can still decide to inline).
-/// However, passing i256 parameters is counter productive and
-/// I've found that splitting it up actualy increases code size.
-/// Should be reviewed after 64bit support.
-pub fn log<'ctx, D>(
+pub fn log<'ctx, D, const N: usize>(
    context: &mut Context<'ctx, D>,
    input_offset: inkwell::values::IntValue<'ctx>,
    input_length: inkwell::values::IntValue<'ctx>,
-    topics: Vec<inkwell::values::IntValue<'ctx>>,
+    topics: [inkwell::values::BasicValueEnum<'ctx>; N],
 ) -> anyhow::Result<()>
 where
    D: Dependency + Clone,
 {
-    let input_offset = context.safe_truncate_int_to_xlen(input_offset)?;
-    let input_length = context.safe_truncate_int_to_xlen(input_length)?;
-    let input_pointer = context.builder().build_ptr_to_int(
-        context.build_heap_gep(input_offset, input_length)?.value,
-        context.xlen_type(),
-        "event_input_offset",
-    )?;
-
-    let arguments = if topics.is_empty() {
-        [
-            context.xlen_type().const_zero().as_basic_value_enum(),
-            context.xlen_type().const_zero().as_basic_value_enum(),
-            input_pointer.as_basic_value_enum(),
-            input_length.as_basic_value_enum(),
-        ]
-    } else {
-        let topics_buffer_size = topics.len() * revive_common::BYTE_LENGTH_WORD;
-        let topics_buffer_pointer = context.build_alloca(
-            context.byte_type().array_type(topics_buffer_size as u32),
-            "topics_buffer",
-        );
-
-        for (n, topic) in topics.iter().enumerate() {
-            let topic_buffer_offset = context
-                .xlen_type()
-                .const_int((n * revive_common::BYTE_LENGTH_WORD) as u64, false);
-            context.build_store(
-                context.build_gep(
-                    topics_buffer_pointer,
-                    &[context.xlen_type().const_zero(), topic_buffer_offset],
-                    context.byte_type(),
-                    "topic_buffer_gep",
-                ),
-                context.build_byte_swap(topic.as_basic_value_enum())?,
-            )?;
-        }
-
-        [
-            context
-                .builder()
-                .build_ptr_to_int(
-                    topics_buffer_pointer.value,
-                    context.xlen_type(),
-                    "event_topics_offset",
-                )?
-                .as_basic_value_enum(),
-            context
-                .xlen_type()
-                .const_int(topics.len() as u64, false)
-                .as_basic_value_enum(),
-            input_pointer.as_basic_value_enum(),
-            input_length.as_basic_value_enum(),
-        ]
-    };
-
-    let _ = context.build_runtime_call(
-        revive_runtime_api::polkavm_imports::DEPOSIT_EVENT,
-        &arguments,
-    );
-
+    let declaration = <EventLog<N> as RuntimeFunction<D>>::declaration(context);
+    let mut arguments = vec![
+        context.safe_truncate_int_to_xlen(input_offset)?.into(),
+        context.safe_truncate_int_to_xlen(input_length)?.into(),
+    ];
+    arguments.extend_from_slice(&topics);
+    context.build_call(declaration, &arguments, "log");
    Ok(())
 }
@@ -4,10 +4,206 @@ use inkwell::types::BasicType;

 use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::code_type::CodeType;
-use crate::polkavm::context::function::runtime;
 use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::polkavm::WriteLLVM;
+
+/// A function for requesting the immutable data from the runtime.
+/// This is a special function that is only used by the front-end generated code.
+///
+/// The runtime API is called lazily and subsequent calls are no-ops.
+///
+/// The bytes written is asserted to match the expected length.
+/// This should never fail; the length is known.
+/// However, this is a one time assertion, hence worth it.
+pub struct Load;
+
+impl<D> RuntimeFunction<D> for Load
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = "__revive_load_immutable_data";
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        context.void_type().fn_type(Default::default(), false)
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
+        let immutable_data_size_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
+            .value
+            .as_pointer_value();
+        let immutable_data_size = context.build_load(
+            Pointer::new(
+                context.xlen_type(),
+                AddressSpace::Stack,
+                immutable_data_size_pointer,
+            ),
+            "immutable_data_size_load",
+        )?;
+
+        let load_immutable_data_block = context.append_basic_block("load_immutables_block");
+        let return_block = context.current_function().borrow().return_block();
+        let immutable_data_size_is_zero = context.builder().build_int_compare(
+            inkwell::IntPredicate::EQ,
+            context.xlen_type().const_zero(),
+            immutable_data_size.into_int_value(),
+            "immutable_data_size_is_zero",
+        )?;
+        context.build_conditional_branch(
+            immutable_data_size_is_zero,
+            return_block,
+            load_immutable_data_block,
+        )?;
+
+        context.set_basic_block(load_immutable_data_block);
+        let output_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
+            .value
+            .as_pointer_value();
+        context.build_runtime_call(
+            revive_runtime_api::polkavm_imports::GET_IMMUTABLE_DATA,
+            &[
+                context
+                    .builder()
+                    .build_ptr_to_int(output_pointer, context.xlen_type(), "ptr_to_xlen")?
+                    .into(),
+                context
+                    .builder()
+                    .build_ptr_to_int(
+                        immutable_data_size_pointer,
+                        context.xlen_type(),
+                        "ptr_to_xlen",
+                    )?
+                    .into(),
+            ],
+        );
+        let bytes_written = context.builder().build_load(
+            context.xlen_type(),
+            immutable_data_size_pointer,
+            "bytes_written",
+        )?;
+        context.builder().build_store(
+            immutable_data_size_pointer,
+            context.xlen_type().const_zero(),
+        )?;
+        let overflow_block = context.append_basic_block("immutable_data_overflow");
+        let is_overflow = context.builder().build_int_compare(
+            inkwell::IntPredicate::UGT,
+            immutable_data_size.into_int_value(),
+            bytes_written.into_int_value(),
+            "is_overflow",
+        )?;
+        context.build_conditional_branch(is_overflow, overflow_block, return_block)?;
+
+        context.set_basic_block(overflow_block);
+        context.build_call(context.intrinsics().trap, &[], "invalid_trap");
+        context.build_unreachable();
+
+        Ok(None)
+    }
+}
+
+impl<D> WriteLLVM<D> for Load
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+/// Store the immutable data from the constructor code.
+pub struct Store;
+
+impl<D> RuntimeFunction<D> for Store
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = "__revive_store_immutable_data";
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        context.void_type().fn_type(Default::default(), false)
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
+        let immutable_data_size_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
+            .value
+            .as_pointer_value();
+        let immutable_data_size = context.build_load(
+            Pointer::new(
+                context.xlen_type(),
+                AddressSpace::Stack,
+                immutable_data_size_pointer,
+            ),
+            "immutable_data_size_load",
+        )?;
+
+        let write_immutable_data_block = context.append_basic_block("write_immutables_block");
+        let join_return_block = context.append_basic_block("join_return_block");
+        let immutable_data_size_is_zero = context.builder().build_int_compare(
+            inkwell::IntPredicate::EQ,
+            context.xlen_type().const_zero(),
+            immutable_data_size.into_int_value(),
+            "immutable_data_size_is_zero",
+        )?;
+        context.build_conditional_branch(
+            immutable_data_size_is_zero,
+            join_return_block,
+            write_immutable_data_block,
+        )?;
+
+        context.set_basic_block(write_immutable_data_block);
+        let immutable_data_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
+            .value
+            .as_pointer_value();
+        context.build_runtime_call(
+            revive_runtime_api::polkavm_imports::SET_IMMUTABLE_DATA,
+            &[
+                context
+                    .builder()
+                    .build_ptr_to_int(
+                        immutable_data_pointer,
+                        context.xlen_type(),
+                        "immutable_data_pointer_to_xlen",
+                    )?
+                    .into(),
+                immutable_data_size,
+            ],
+        );
+        context.build_unconditional_branch(join_return_block);
+
+        context.set_basic_block(join_return_block);
+        Ok(None)
+    }
+}
+
+impl<D> WriteLLVM<D> for Store
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}

 /// Translates the contract immutable load.
 ///
@@ -27,14 +223,15 @@ where
        }
        Some(CodeType::Deploy) => load_from_memory(context, index),
        Some(CodeType::Runtime) => {
+            let name = <Load as RuntimeFunction<D>>::NAME;
            context.build_call(
                context
-                    .get_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA)
+                    .get_function(name)
                    .expect("is always declared for runtime code")
                    .borrow()
                    .declaration(),
                &[],
-                runtime::FUNCTION_LOAD_IMMUTABLE_DATA,
+                name,
            );
            load_from_memory(context, index)
        }
@@ -85,5 +85,14 @@ where
        offset,
        "mstore8_destination",
    );
-    context.build_store(pointer, value)
+    let pointer = context.build_sbrk(
+        pointer.to_int(context),
+        context.xlen_type().const_int(1, false),
+    )?;
+    context
+        .builder()
+        .build_store(pointer, value)?
+        .set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
+        .expect("Alignment is valid");
+    Ok(())
 }
@@ -1,9 +1,9 @@
 //! Translates the transaction return operations.

-use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::code_type::CodeType;
-use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
+use crate::polkavm::evm::immutable::Store;
 use crate::polkavm::Dependency;

 /// Translates the `return` instruction.
@@ -18,55 +18,11 @@ where
    match context.code_type() {
        None => anyhow::bail!("Return is not available if the contract part is undefined"),
        Some(CodeType::Deploy) => {
-            let immutable_data_size_pointer = context
-                .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
-                .value
-                .as_pointer_value();
-            let immutable_data_size = context.build_load(
-                Pointer::new(
-                    context.xlen_type(),
-                    AddressSpace::Stack,
-                    immutable_data_size_pointer,
-                ),
-                "immutable_data_size_load",
-            )?;
-
-            let write_immutable_data_block = context.append_basic_block("write_immutables_block");
-            let join_return_block = context.append_basic_block("join_return_block");
-            let immutable_data_size_is_zero = context.builder().build_int_compare(
-                inkwell::IntPredicate::EQ,
-                context.xlen_type().const_zero(),
-                immutable_data_size.into_int_value(),
-                "immutable_data_size_is_zero",
-            )?;
-            context.build_conditional_branch(
-                immutable_data_size_is_zero,
-                join_return_block,
-                write_immutable_data_block,
-            )?;
-
-            context.set_basic_block(write_immutable_data_block);
-            let immutable_data_pointer = context
-                .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
-                .value
-                .as_pointer_value();
-            context.build_runtime_call(
-                revive_runtime_api::polkavm_imports::SET_IMMUTABLE_DATA,
-                &[
-                    context
-                        .builder()
-                        .build_ptr_to_int(
-                            immutable_data_pointer,
-                            context.xlen_type(),
-                            "immutable_data_pointer_to_xlen",
-                        )?
-                        .into(),
-                    immutable_data_size,
-                ],
+            context.build_call(
+                <Store as RuntimeFunction<D>>::declaration(context),
+                Default::default(),
+                "store_immutable_data",
            );
-            context.build_unconditional_branch(join_return_block);
-
-            context.set_basic_block(join_return_block);
        }
        Some(CodeType::Runtime) => {}
    }
@@ -100,11 +56,7 @@ pub fn stop<D>(context: &mut Context<D>) -> anyhow::Result<()>
 where
    D: Dependency + Clone,
 {
-    r#return(
-        context,
-        context.integer_const(crate::polkavm::XLEN, 0),
-        context.integer_const(crate::polkavm::XLEN, 0),
-    )
+    r#return(context, context.word_const(0), context.word_const(0))
 }

 /// Translates the `invalid` instruction.
@@ -1,8 +1,10 @@
 //! Translates the storage operations.

-use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::PolkaVMLoadStorageWordFunction;
+use crate::PolkaVMStoreStorageWordFunction;

 /// Translates the storage load.
 pub fn load<'ctx, D>(
@@ -12,10 +14,12 @@ pub fn load<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
-    slot_ptr.address_space = AddressSpace::Storage;
-    context.builder().build_store(slot_ptr.value, position)?;
-    context.build_load(slot_ptr, "storage_load_value")
+    let name = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::declaration(context);
+    let arguments = [context.xlen_type().const_zero().into(), position.into()];
+    Ok(context
+        .build_call(declaration, &arguments, "storage_load")
+        .unwrap_or_else(|| panic!("runtime function {name} should return a value")))
 }

 /// Translates the storage store.
@@ -27,10 +31,13 @@ pub fn store<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
-    slot_ptr.address_space = AddressSpace::Storage;
-    context.builder().build_store(slot_ptr.value, position)?;
-    context.build_store(slot_ptr, value)?;
+    let declaration = <PolkaVMStoreStorageWordFunction as RuntimeFunction<D>>::declaration(context);
+    let arguments = [
+        context.xlen_type().const_zero().into(),
+        position.into(),
+        value.into(),
+    ];
+    context.build_call(declaration, &arguments, "storage_store");
    Ok(())
 }

@@ -42,10 +49,15 @@ pub fn transient_load<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
-    slot_ptr.address_space = AddressSpace::TransientStorage;
-    context.builder().build_store(slot_ptr.value, position)?;
-    context.build_load(slot_ptr, "transient_storage_load_value")
+    let name = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::NAME;
+    let declaration = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::declaration(context);
+    let arguments = [
+        context.xlen_type().const_int(1, false).into(),
+        position.into(),
+    ];
+    Ok(context
+        .build_call(declaration, &arguments, "storage_load")
+        .unwrap_or_else(|| panic!("runtime function {name} should return a value")))
 }

 /// Translates the transient storage store.
@@ -57,9 +69,12 @@ pub fn transient_store<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
-    slot_ptr.address_space = AddressSpace::TransientStorage;
-    context.builder().build_store(slot_ptr.value, position)?;
-    context.build_store(slot_ptr, value)?;
+    let declaration = <PolkaVMStoreStorageWordFunction as RuntimeFunction<D>>::declaration(context);
+    let arguments = [
+        context.xlen_type().const_int(1, false).into(),
+        position.into(),
+        value.into(),
+    ];
+    context.build_call(declaration, &arguments, "storage_store");
    Ok(())
 }