rename target to polkavm

Signed-off-by: xermicus <cyrill@parity.io>

crates/llvm-context/src/polkavm/evm/arithmetic.rs

@@ -0,0 +1,132 @@
+//! Translates the arithmetic operations.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the arithmetic addition.
+pub fn addition<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_int_add(operand_1, operand_2, "addition_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the arithmetic subtraction.
+pub fn subtraction<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_int_sub(operand_1, operand_2, "subtraction_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the arithmetic multiplication.
+pub fn multiplication<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_int_mul(operand_1, operand_2, "multiplication_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the arithmetic division.
+pub fn division<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_int_unsigned_div(operand_1, operand_2, "udiv")?
+        .into())
+}
+
+/// Translates the arithmetic remainder.
+pub fn remainder<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().r#mod,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+            ],
+            "add_mod_call",
+        )
+        .expect("Always exists"))
+}
+
+/// Translates the signed arithmetic division.
+/// Two differences between the EVM and LLVM IR:
+/// 1. In case of division by zero, 0 is returned.
+/// 2. In case of overflow, the first argument is returned.
+pub fn division_signed<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().sdiv,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+            ],
+            "add_mod_call",
+        )
+        .expect("Always exists"))
+}
+
+/// Translates the signed arithmetic remainder.
+pub fn remainder_signed<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().smod,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+            ],
+            "add_mod_call",
+        )
+        .expect("Always exists"))
+}

crates/llvm-context/src/polkavm/evm/bitwise.rs

@@ -0,0 +1,219 @@
+//! Translates the bitwise operations.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the bitwise OR.
+pub fn or<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_or(operand_1, operand_2, "or_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the bitwise XOR.
+pub fn xor<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_xor(operand_1, operand_2, "xor_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the bitwise AND.
+pub fn and<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .builder()
+        .build_and(operand_1, operand_2, "and_result")?
+        .as_basic_value_enum())
+}
+
+/// Translates the bitwise shift left.
+pub fn shift_left<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    shift: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let overflow_block = context.append_basic_block("shift_left_overflow");
+    let non_overflow_block = context.append_basic_block("shift_left_non_overflow");
+    let join_block = context.append_basic_block("shift_left_join");
+
+    let result_pointer = context.build_alloca(context.field_type(), "shift_left_result_pointer");
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
+        "shift_left_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    context.build_store(result_pointer, context.field_const(0))?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value =
+        context
+            .builder()
+            .build_left_shift(value, shift, "shift_left_non_overflow_result")?;
+    context.build_store(result_pointer, value)?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    context.build_load(result_pointer, "shift_left_result")
+}
+
+/// Translates the bitwise shift right.
+pub fn shift_right<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    shift: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let overflow_block = context.append_basic_block("shift_right_overflow");
+    let non_overflow_block = context.append_basic_block("shift_right_non_overflow");
+    let join_block = context.append_basic_block("shift_right_join");
+
+    let result_pointer = context.build_alloca(context.field_type(), "shift_right_result_pointer");
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
+        "shift_right_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    context.build_store(result_pointer, context.field_const(0))?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value = context.builder().build_right_shift(
+        value,
+        shift,
+        false,
+        "shift_right_non_overflow_result",
+    )?;
+    context.build_store(result_pointer, value)?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    context.build_load(result_pointer, "shift_right_result")
+}
+
+/// Translates the arithmetic bitwise shift right.
+pub fn shift_right_arithmetic<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    shift: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let overflow_block = context.append_basic_block("shift_right_arithmetic_overflow");
+    let overflow_positive_block =
+        context.append_basic_block("shift_right_arithmetic_overflow_positive");
+    let overflow_negative_block =
+        context.append_basic_block("shift_right_arithmetic_overflow_negative");
+    let non_overflow_block = context.append_basic_block("shift_right_arithmetic_non_overflow");
+    let join_block = context.append_basic_block("shift_right_arithmetic_join");
+
+    let result_pointer = context.build_alloca(
+        context.field_type(),
+        "shift_right_arithmetic_result_pointer",
+    );
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
+        "shift_right_arithmetic_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    let sign_bit = context.builder().build_right_shift(
+        value,
+        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
+        false,
+        "shift_right_arithmetic_sign_bit",
+    )?;
+    let condition_is_negative = context.builder().build_int_truncate_or_bit_cast(
+        sign_bit,
+        context.bool_type(),
+        "shift_right_arithmetic_sign_bit_truncated",
+    )?;
+    context.build_conditional_branch(
+        condition_is_negative,
+        overflow_negative_block,
+        overflow_positive_block,
+    )?;
+
+    context.set_basic_block(overflow_positive_block);
+    context.build_store(result_pointer, context.field_const(0))?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(overflow_negative_block);
+    context.build_store(result_pointer, context.field_type().const_all_ones())?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value = context.builder().build_right_shift(
+        value,
+        shift,
+        true,
+        "shift_right_arithmetic_non_overflow_result",
+    )?;
+    context.build_store(result_pointer, value)?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    context.build_load(result_pointer, "shift_right_arithmetic_result")
+}
+
+/// Translates the `byte` instruction.
+pub fn byte<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().byte,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+            ],
+            "byte_call",
+        )
+        .expect("Always exists"))
+}

crates/llvm-context/src/polkavm/evm/call.rs

@@ -0,0 +1,109 @@
+//! Translates a contract call.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::argument::Argument;
+use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates a contract call.
+/// If the `simulation_address` is specified, the call is substituted with another instruction
+/// according to the specification.
+#[allow(clippy::too_many_arguments)]
+pub fn default<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _function: FunctionDeclaration<'ctx>,
+    _gas: inkwell::values::IntValue<'ctx>,
+    _address: inkwell::values::IntValue<'ctx>,
+    _value: Option<inkwell::values::IntValue<'ctx>>,
+    _input_offset: inkwell::values::IntValue<'ctx>,
+    _input_length: inkwell::values::IntValue<'ctx>,
+    _output_offset: inkwell::values::IntValue<'ctx>,
+    _output_length: inkwell::values::IntValue<'ctx>,
+    _constants: Vec<Option<num::BigUint>>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!();
+
+    /*
+    let ordinary_block = context.append_basic_block("contract_call_ordinary_block");
+    let join_block = context.append_basic_block("contract_call_join_block");
+
+    let result_pointer = context.build_alloca(context.field_type(), "contract_call_result_pointer");
+    context.build_store(result_pointer, context.field_const(0));
+
+    context.builder().build_switch(
+        address,
+        ordinary_block,
+        &[(
+            context.field_const(zkevm_opcode_defs::ADDRESS_IDENTITY.into()),
+            identity_block,
+        )],
+    )?;
+
+    {
+        context.set_basic_block(identity_block);
+        let result = identity(context, output_offset, input_offset, output_length)?;
+        context.build_store(result_pointer, result);
+        context.build_unconditional_branch(join_block);
+    }
+
+    context.set_basic_block(ordinary_block);
+    let result = if let Some(value) = value {
+        default_wrapped(
+            context,
+            function,
+            gas,
+            value,
+            address,
+            input_offset,
+            input_length,
+            output_offset,
+            output_length,
+        )?
+    } else {
+        let function = Runtime::default_call(context, function);
+        context
+            .build_call(
+                function,
+                &[
+                    gas.as_basic_value_enum(),
+                    address.as_basic_value_enum(),
+                    input_offset.as_basic_value_enum(),
+                    input_length.as_basic_value_enum(),
+                    output_offset.as_basic_value_enum(),
+                    output_length.as_basic_value_enum(),
+                ],
+                "default_call",
+            )
+            .expect("Always exists")
+    };
+    context.build_store(result_pointer, result);
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    let result = context.build_load(result_pointer, "contract_call_result");
+    Ok(result)
+    */
+}
+
+/// Translates the Yul `linkersymbol` instruction.
+pub fn linker_symbol<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    mut arguments: [Argument<'ctx>; 1],
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let path = arguments[0]
+        .original
+        .take()
+        .ok_or_else(|| anyhow::anyhow!("Linker symbol literal is missing"))?;
+
+    Ok(context
+        .resolve_library(path.as_str())?
+        .as_basic_value_enum())
+}

crates/llvm-context/src/polkavm/evm/calldata.rs

@@ -0,0 +1,76 @@
+//! Translates the calldata instructions.
+
+use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+use inkwell::types::BasicType;
+
+/// Translates the calldata load.
+pub fn load<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let calldata_pointer = context
+        .get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
+        .value
+        .as_pointer_value();
+    let offset = context.build_gep(
+        Pointer::new(context.byte_type(), AddressSpace::Stack, calldata_pointer),
+        &[offset],
+        context.field_type().as_basic_type_enum(),
+        "calldata_pointer_with_offset",
+    );
+    context
+        .build_load(offset, "calldata_value")
+        .map(|value| context.build_byte_swap(value))
+}
+
+/// Translates the calldata size.
+pub fn size<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let value = context.get_global_value(crate::polkavm::GLOBAL_CALLDATA_SIZE)?;
+
+    Ok(value)
+}
+
+/// Translates the calldata copy.
+pub fn copy<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    destination_offset: inkwell::values::IntValue<'ctx>,
+    source_offset: inkwell::values::IntValue<'ctx>,
+    size: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let offset = context.safe_truncate_int_to_i32(destination_offset)?;
+    let size = context.safe_truncate_int_to_i32(size)?;
+    let destination = context.build_heap_gep(offset, size)?;
+
+    let calldata_pointer = context
+        .get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
+        .value
+        .as_pointer_value();
+    let source = context.build_gep(
+        Pointer::new(context.byte_type(), AddressSpace::Stack, calldata_pointer),
+        &[context.safe_truncate_int_to_i32(source_offset)?],
+        context.byte_type(),
+        "calldata_pointer_with_offset",
+    );
+
+    context.build_memcpy(
+        context.intrinsics().memory_copy_from_generic,
+        destination,
+        source,
+        size,
+        "calldata_copy_memcpy_from_child",
+    )
+}

crates/llvm-context/src/polkavm/evm/comparison.rs

@@ -0,0 +1,31 @@
+//! Translates the comparison operations.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the comparison operations.
+/// There is not difference between the EVM and LLVM IR behaviors.
+pub fn compare<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+    operation: inkwell::IntPredicate,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let result = context.builder().build_int_compare(
+        operation,
+        operand_1,
+        operand_2,
+        "comparison_result",
+    )?;
+    let result = context.builder().build_int_z_extend_or_bit_cast(
+        result,
+        context.field_type(),
+        "comparison_result_extended",
+    )?;
+    Ok(result.as_basic_value_enum())
+}

crates/llvm-context/src/polkavm/evm/context.rs

@@ -0,0 +1,134 @@
+//! Translates the context getter instructions.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `gas_limit` instruction.
+pub fn gas_limit<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `gas_price` instruction.
+pub fn gas_price<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `tx.origin` instruction.
+pub fn origin<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `chain_id` instruction.
+pub fn chain_id<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `block_number` instruction.
+pub fn block_number<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `block_timestamp` instruction.
+pub fn block_timestamp<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `block_hash` instruction.
+pub fn block_hash<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _index: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `difficulty` instruction.
+pub fn difficulty<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `coinbase` instruction.
+pub fn coinbase<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `basefee` instruction.
+pub fn basefee<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `msize` instruction.
+pub fn msize<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let heap_end = context.build_sbrk(context.xlen_type().const_zero())?;
+    let heap_start = context
+        .get_global(crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER)?
+        .value
+        .as_pointer_value();
+    let heap_size = context.builder().build_int_nuw_sub(
+        context
+            .builder()
+            .build_ptr_to_int(heap_end, context.xlen_type(), "heap_end")?,
+        context
+            .builder()
+            .build_ptr_to_int(heap_start, context.xlen_type(), "heap_start")?,
+        "heap_size",
+    )?;
+    Ok(context
+        .builder()
+        .build_int_z_extend(heap_size, context.field_type(), "heap_size_extended")?
+        .as_basic_value_enum())
+}

crates/llvm-context/src/polkavm/evm/create.rs

@@ -0,0 +1,170 @@
+//! Translates the contract creation instructions.
+
+use inkwell::values::BasicValue;
+use num::Zero;
+
+use crate::polkavm::context::argument::Argument;
+use crate::polkavm::context::code_type::CodeType;
+use crate::polkavm::context::function::runtime::Runtime;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the contract `create` instruction.
+/// The instruction is simulated by a call to a system contract.
+pub fn create<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    value: inkwell::values::IntValue<'ctx>,
+    input_offset: inkwell::values::IntValue<'ctx>,
+    input_length: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let signature_hash_string =
+        crate::polkavm::utils::keccak256(crate::polkavm::DEPLOYER_SIGNATURE_CREATE.as_bytes());
+    let signature_hash = context.field_const_str_hex(signature_hash_string.as_str());
+
+    let salt = context.field_const(0);
+
+    let function = Runtime::deployer_call(context);
+    let result = context
+        .build_call(
+            function,
+            &[
+                value.as_basic_value_enum(),
+                input_offset.as_basic_value_enum(),
+                input_length.as_basic_value_enum(),
+                signature_hash.as_basic_value_enum(),
+                salt.as_basic_value_enum(),
+            ],
+            "create_deployer_call",
+        )
+        .expect("Always exists");
+
+    Ok(result)
+}
+
+/// Translates the contract `create2` instruction.
+/// The instruction is simulated by a call to a system contract.
+pub fn create2<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    value: inkwell::values::IntValue<'ctx>,
+    input_offset: inkwell::values::IntValue<'ctx>,
+    input_length: inkwell::values::IntValue<'ctx>,
+    salt: Option<inkwell::values::IntValue<'ctx>>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let signature_hash_string =
+        crate::polkavm::utils::keccak256(crate::polkavm::DEPLOYER_SIGNATURE_CREATE2.as_bytes());
+    let signature_hash = context.field_const_str_hex(signature_hash_string.as_str());
+
+    let salt = salt.unwrap_or_else(|| context.field_const(0));
+
+    let function = Runtime::deployer_call(context);
+    let result = context
+        .build_call(
+            function,
+            &[
+                value.as_basic_value_enum(),
+                input_offset.as_basic_value_enum(),
+                input_length.as_basic_value_enum(),
+                signature_hash.as_basic_value_enum(),
+                salt.as_basic_value_enum(),
+            ],
+            "create2_deployer_call",
+        )
+        .expect("Always exists");
+
+    Ok(result)
+}
+
+/// Translates the contract hash instruction, which is actually used to set the hash of the contract
+/// being created, or other related auxiliary data.
+/// Represents `dataoffset` in Yul and `PUSH [$]` in the EVM legacy assembly.
+pub fn contract_hash<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    identifier: String,
+) -> anyhow::Result<Argument<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let code_type = context
+        .code_type()
+        .ok_or_else(|| anyhow::anyhow!("The contract code part type is undefined"))?;
+
+    let parent = context.module().get_name().to_str().expect("Always valid");
+
+    let contract_path =
+        context
+            .resolve_path(identifier.as_str())
+            .map_err(|error| match code_type {
+                CodeType::Runtime if identifier.ends_with("_deployed") => {
+                    anyhow::anyhow!("type({}).runtimeCode is not supported", identifier)
+                }
+                _ => error,
+            })?;
+    if contract_path.as_str() == parent {
+        return Ok(Argument::new_with_constant(
+            context.field_const(0).as_basic_value_enum(),
+            num::BigUint::zero(),
+        ));
+    } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
+        anyhow::bail!("type({}).runtimeCode is not supported", identifier);
+    }
+
+    let hash_string = context.compile_dependency(identifier.as_str())?;
+    let hash_value = context
+        .field_const_str_hex(hash_string.as_str())
+        .as_basic_value_enum();
+    Ok(Argument::new_with_original(hash_value, hash_string))
+}
+
+/// Translates the deployer call header size instruction, Usually, the header consists of:
+/// - the deployer contract method signature
+/// - the salt if the call is `create2`, or zero if the call is `create1`
+/// - the hash of the bytecode of the contract whose instance is being created
+/// - the offset of the constructor arguments
+/// - the length of the constructor arguments
+/// If the call is `create1`, the space for the salt is still allocated, because the memory for the
+/// header is allocated by the Yul or EVM legacy assembly before it is known which version of
+/// `create` is going to be used.
+/// Represents `datasize` in Yul and `PUSH #[$]` in the EVM legacy assembly.
+pub fn header_size<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    identifier: String,
+) -> anyhow::Result<Argument<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let code_type = context
+        .code_type()
+        .ok_or_else(|| anyhow::anyhow!("The contract code part type is undefined"))?;
+
+    let parent = context.module().get_name().to_str().expect("Always valid");
+
+    let contract_path =
+        context
+            .resolve_path(identifier.as_str())
+            .map_err(|error| match code_type {
+                CodeType::Runtime if identifier.ends_with("_deployed") => {
+                    anyhow::anyhow!("type({}).runtimeCode is not supported", identifier)
+                }
+                _ => error,
+            })?;
+    if contract_path.as_str() == parent {
+        return Ok(Argument::new_with_constant(
+            context.field_const(0).as_basic_value_enum(),
+            num::BigUint::zero(),
+        ));
+    } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
+        anyhow::bail!("type({}).runtimeCode is not supported", identifier);
+    }
+
+    let size_bigint = num::BigUint::from(crate::polkavm::DEPLOYER_CALL_HEADER_SIZE);
+    let size_value = context
+        .field_const(crate::polkavm::DEPLOYER_CALL_HEADER_SIZE as u64)
+        .as_basic_value_enum();
+    Ok(Argument::new_with_constant(size_value, size_bigint))
+}

crates/llvm-context/src/polkavm/evm/crypto.rs

@@ -0,0 +1,47 @@
+//! Translates the cryptographic operations.
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `sha3` instruction.
+pub fn sha3<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+    length: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let offset_casted = context.safe_truncate_int_to_i32(offset)?;
+    let length_casted = context.safe_truncate_int_to_i32(length)?;
+    let input_pointer = context.build_heap_gep(offset_casted, length_casted)?;
+    let input_pointer_casted = context.builder().build_ptr_to_int(
+        input_pointer.value,
+        context.xlen_type(),
+        "input_pointer_casted",
+    )?;
+
+    let output_pointer = context.build_alloca(context.field_type(), "output_pointer");
+    let output_pointer_casted = context.builder().build_ptr_to_int(
+        output_pointer.value,
+        context.xlen_type(),
+        "output_pointer_casted",
+    )?;
+
+    let function = context
+        .module()
+        .get_function("hash_keccak_256")
+        .expect("is declared");
+
+    context.builder().build_call(
+        function,
+        &[
+            input_pointer_casted.into(),
+            length_casted.into(),
+            output_pointer_casted.into(),
+        ],
+        "call_seal_hash_keccak_256",
+    )?;
+
+    Ok(context.build_byte_swap(context.build_load(output_pointer, "sha3_output")?))
+}

crates/llvm-context/src/polkavm/evm/ether_gas.rs

@@ -0,0 +1,76 @@
+//! Translates the value and balance operations.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `gas` instruction.
+pub fn gas<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context.integer_const(256, 0).as_basic_value_enum())
+}
+
+/// Translates the `value` instruction.
+pub fn value<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let output_pointer = context.build_alloca(context.value_type(), "output_pointer");
+    let output_pointer_casted = context.builder().build_ptr_to_int(
+        output_pointer.value,
+        context.xlen_type(),
+        "output_pointer_casted",
+    )?;
+
+    let output_length_pointer = context.build_alloca(context.xlen_type(), "output_len_pointer");
+    let output_length_pointer_casted = context.builder().build_ptr_to_int(
+        output_length_pointer.value,
+        context.xlen_type(),
+        "output_pointer_casted",
+    )?;
+    context.build_store(
+        output_length_pointer,
+        context.integer_const(
+            crate::polkavm::XLEN,
+            revive_common::BYTE_LENGTH_VALUE as u64,
+        ),
+    )?;
+
+    context.builder().build_call(
+        context
+            .module()
+            .get_function("value_transferred")
+            .expect("is declared"),
+        &[
+            output_pointer_casted.into(),
+            output_length_pointer_casted.into(),
+        ],
+        "call_seal_value_transferred",
+    )?;
+
+    let value = context.build_load(output_pointer, "transferred_value")?;
+    let value_extended = context.builder().build_int_z_extend(
+        value.into_int_value(),
+        context.field_type(),
+        "transferred_value_extended",
+    )?;
+    Ok(value_extended.as_basic_value_enum())
+}
+
+/// Translates the `balance` instructions.
+pub fn balance<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _address: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}

crates/llvm-context/src/polkavm/evm/event.rs

@@ -0,0 +1,72 @@
+//! Translates a log or event call.
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates a log or event call.
+/// The decoding logic is implemented in a system contract, which is called from here.
+/// There are several cases of the translation for the sake of efficiency, since the front-end
+/// emits topics and values sequentially by one, but the LLVM intrinsic and bytecode instruction
+/// accept two at once.
+pub fn log<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _input_offset: inkwell::values::IntValue<'ctx>,
+    _input_length: inkwell::values::IntValue<'ctx>,
+    _topics: Vec<inkwell::values::IntValue<'ctx>>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    /*
+    let failure_block = context.append_basic_block("event_failure_block");
+    let join_block = context.append_basic_block("event_join_block");
+
+    let gas = crate::polkavm::evm::ether_gas::gas(context)?.into_int_value();
+    let abi_data = crate::polkavm::utils::abi_data(
+        context,
+        input_offset,
+        input_length,
+        Some(gas),
+        AddressSpace::Heap,
+        true,
+    )?;
+    let mut extra_abi_data = Vec::with_capacity(1 + topics.len());
+    extra_abi_data.push(context.field_const(topics.len() as u64));
+    extra_abi_data.extend(topics);
+
+    let result = context
+        .build_call(
+            context.llvm_runtime().far_call,
+            crate::polkavm::utils::external_call_arguments(
+                context,
+                abi_data.as_basic_value_enum(),
+                context.field_const(zkevm_opcode_defs::ADDRESS_EVENT_WRITER as u64),
+                extra_abi_data,
+                None,
+            )
+            .as_slice(),
+            "event_writer_call_external",
+        )
+        .expect("Always returns a value");
+
+    let result_status_code_boolean = context
+        .builder()
+        .build_extract_value(
+            result.into_struct_value(),
+            1,
+            "event_writer_external_result_status_code_boolean",
+        )
+        .expect("Always exists");
+    context.build_conditional_branch(
+        result_status_code_boolean.into_int_value(),
+        join_block,
+        failure_block,
+    )?;
+
+    context.set_basic_block(failure_block);
+    crate::polkavm::evm::r#return::revert(context, context.field_const(0), context.field_const(0))?;
+
+    context.set_basic_block(join_block);
+    */
+    Ok(())
+}

crates/llvm-context/src/polkavm/evm/ext_code.rs

@@ -0,0 +1,26 @@
+//! Translates the external code operations.
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `extcodesize` instruction.
+pub fn size<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _address: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}
+
+/// Translates the `extcodehash` instruction.
+pub fn hash<'ctx, D>(
+    _context: &mut Context<'ctx, D>,
+    _address: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    todo!()
+}

crates/llvm-context/src/polkavm/evm/immutable.rs

@@ -0,0 +1,111 @@
+//! Translates the contract immutable 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::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the contract immutable load.
+/// In the deploy code the values are read from the auxiliary heap.
+/// In the runtime code they are requested from the system contract.
+pub fn load<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    index: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    match context.code_type() {
+        None => {
+            anyhow::bail!("Immutables are not available if the contract part is undefined");
+        }
+        Some(CodeType::Deploy) => {
+            let index_double = context.builder().build_int_mul(
+                index,
+                context.field_const(2),
+                "immutable_load_index_double",
+            )?;
+            let offset_absolute = context.builder().build_int_add(
+                index_double,
+                context.field_const(
+                    crate::polkavm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
+                        + (3 * revive_common::BYTE_LENGTH_FIELD) as u64,
+                ),
+                "immutable_offset_absolute",
+            )?;
+            let immutable_pointer = Pointer::new_with_offset(
+                context,
+                AddressSpace::HeapAuxiliary,
+                context.field_type(),
+                offset_absolute,
+                "immutable_pointer",
+            );
+            context.build_load(immutable_pointer, "immutable_value")
+        }
+        Some(CodeType::Runtime) => {
+            todo!()
+        }
+    }
+}
+
+/// Translates the contract immutable store.
+/// In the deploy code the values are written to the auxiliary heap at the predefined offset,
+/// being prepared for returning to the system contract for saving.
+/// Ignored in the runtime code.
+pub fn store<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    index: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    match context.code_type() {
+        None => {
+            anyhow::bail!("Immutables are not available if the contract part is undefined");
+        }
+        Some(CodeType::Deploy) => {
+            let index_double = context.builder().build_int_mul(
+                index,
+                context.field_const(2),
+                "immutable_load_index_double",
+            )?;
+            let index_offset_absolute = context.builder().build_int_add(
+                index_double,
+                context.field_const(
+                    crate::polkavm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
+                        + (2 * revive_common::BYTE_LENGTH_FIELD) as u64,
+                ),
+                "index_offset_absolute",
+            )?;
+            let index_offset_pointer = Pointer::new_with_offset(
+                context,
+                AddressSpace::HeapAuxiliary,
+                context.field_type(),
+                index_offset_absolute,
+                "immutable_index_pointer",
+            );
+            context.build_store(index_offset_pointer, index)?;
+
+            let value_offset_absolute = context.builder().build_int_add(
+                index_offset_absolute,
+                context.field_const(revive_common::BYTE_LENGTH_FIELD as u64),
+                "value_offset_absolute",
+            )?;
+            let value_offset_pointer = Pointer::new_with_offset(
+                context,
+                AddressSpace::HeapAuxiliary,
+                context.field_type(),
+                value_offset_absolute,
+                "immutable_value_pointer",
+            );
+            context.build_store(value_offset_pointer, value)?;
+
+            Ok(())
+        }
+        Some(CodeType::Runtime) => {
+            anyhow::bail!("Immutable writes are not available in the runtime code");
+        }
+    }
+}

crates/llvm-context/src/polkavm/evm/math.rs

@@ -0,0 +1,88 @@
+//! Translates the mathematical operations.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `addmod` instruction.
+pub fn add_mod<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+    modulo: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().add_mod,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+                modulo.as_basic_value_enum(),
+            ],
+            "add_mod_call",
+        )
+        .expect("Always exists"))
+}
+
+/// Translates the `mulmod` instruction.
+pub fn mul_mod<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    operand_1: inkwell::values::IntValue<'ctx>,
+    operand_2: inkwell::values::IntValue<'ctx>,
+    modulo: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().mul_mod,
+            &[
+                operand_1.as_basic_value_enum(),
+                operand_2.as_basic_value_enum(),
+                modulo.as_basic_value_enum(),
+            ],
+            "mul_mod_call",
+        )
+        .expect("Always exists"))
+}
+
+/// Translates the `exp` instruction.
+pub fn exponent<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    value: inkwell::values::IntValue<'ctx>,
+    exponent: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().exp,
+            &[value.as_basic_value_enum(), exponent.as_basic_value_enum()],
+            "exp_call",
+        )
+        .expect("Always exists"))
+}
+
+/// Translates the `signextend` instruction.
+pub fn sign_extend<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    bytes: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    Ok(context
+        .build_call(
+            context.llvm_runtime().sign_extend,
+            &[bytes.as_basic_value_enum(), value.as_basic_value_enum()],
+            "sign_extend_call",
+        )
+        .expect("Always exists"))
+}

crates/llvm-context/src/polkavm/evm/memory.rs

@@ -0,0 +1,70 @@
+//! Translates the heap memory operations.
+
+use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `mload` instruction.
+/// Uses the main heap.
+pub fn load<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::Heap,
+        context.field_type(),
+        offset,
+        "memory_load_pointer",
+    );
+    context.build_load(pointer, "memory_load_result")
+}
+
+/// Translates the `mstore` instruction.
+/// Uses the main heap.
+pub fn store<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::Heap,
+        context.field_type(),
+        offset,
+        "memory_store_pointer",
+    );
+    context.build_store(pointer, value)?;
+    Ok(())
+}
+
+/// Translates the `mstore8` instruction.
+/// Uses the main heap.
+pub fn store_byte<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let byte_type = context.byte_type();
+    let value = context
+        .builder()
+        .build_int_truncate(value, byte_type, "mstore8_value")?;
+    let pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::Heap,
+        byte_type,
+        offset,
+        "mstore8_destination",
+    );
+    context.build_store(pointer, value)
+}

crates/llvm-context/src/polkavm/evm/mod.rs

@@ -0,0 +1,19 @@
+//! The EVM instructions translation utils.
+
+pub mod arithmetic;
+pub mod bitwise;
+pub mod call;
+pub mod calldata;
+pub mod comparison;
+pub mod context;
+pub mod create;
+pub mod crypto;
+pub mod ether_gas;
+pub mod event;
+pub mod ext_code;
+pub mod immutable;
+pub mod math;
+pub mod memory;
+pub mod r#return;
+pub mod return_data;
+pub mod storage;

crates/llvm-context/src/polkavm/evm/return.rs

@@ -0,0 +1,115 @@
+//! 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::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the `return` instruction.
+/// Unlike in EVM, zkSync constructors return the array of contract immutables.
+pub fn r#return<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+    length: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    match context.code_type() {
+        None => {
+            anyhow::bail!("Return is not available if the contract part is undefined");
+        }
+        Some(CodeType::Deploy) => {
+            let immutables_offset_pointer = Pointer::new_with_offset(
+                context,
+                AddressSpace::HeapAuxiliary,
+                context.field_type(),
+                context.field_const(crate::polkavm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA),
+                "immutables_offset_pointer",
+            );
+            context.build_store(
+                immutables_offset_pointer,
+                context.field_const(revive_common::BYTE_LENGTH_FIELD as u64),
+            )?;
+
+            let immutables_number_pointer = Pointer::new_with_offset(
+                context,
+                AddressSpace::HeapAuxiliary,
+                context.field_type(),
+                context.field_const(
+                    crate::polkavm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
+                        + (revive_common::BYTE_LENGTH_FIELD as u64),
+                ),
+                "immutables_number_pointer",
+            );
+            let immutable_values_size = context.immutables_size()?;
+            context.build_store(
+                immutables_number_pointer,
+                context
+                    .field_const((immutable_values_size / revive_common::BYTE_LENGTH_FIELD) as u64),
+            )?;
+            let immutables_size = context.builder().build_int_mul(
+                context.field_const(immutable_values_size as u64),
+                context.field_const(2),
+                "immutables_size",
+            )?;
+            let return_data_length = context.builder().build_int_add(
+                immutables_size,
+                context.field_const((revive_common::BYTE_LENGTH_FIELD * 2) as u64),
+                "return_data_length",
+            )?;
+
+            context.build_exit(
+                context.integer_const(32, 0),
+                context.field_const(crate::polkavm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA),
+                return_data_length,
+            )?;
+        }
+        Some(CodeType::Runtime) => {
+            context.build_exit(context.integer_const(32, 0), offset, length)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Translates the `revert` instruction.
+pub fn revert<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    offset: inkwell::values::IntValue<'ctx>,
+    length: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    context.build_exit(context.integer_const(32, 1), offset, length)
+}
+
+/// Translates the `stop` instruction.
+/// Is the same as `return(0, 0)`.
+pub fn stop<D>(context: &mut Context<D>) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    r#return(
+        context,
+        context.integer_const(32, 0),
+        context.integer_const(32, 0),
+    )
+}
+
+/// Translates the `invalid` instruction.
+/// Burns all gas using an out-of-bounds memory store, causing a panic.
+pub fn invalid<D>(context: &mut Context<D>) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    crate::polkavm::evm::memory::store(
+        context,
+        context.field_type().const_all_ones(),
+        context.field_const(0),
+    )?;
+    context.build_call(context.intrinsics().trap, &[], "invalid_trap");
+    Ok(())
+}

crates/llvm-context/src/polkavm/evm/return_data.rs

@@ -0,0 +1,87 @@
+//! Translates the return data instructions.
+
+use inkwell::types::BasicType;
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the return data size.
+pub fn size<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    match context.get_global_value(crate::polkavm::GLOBAL_RETURN_DATA_SIZE) {
+        Ok(global) => Ok(global),
+        Err(_error) => Ok(context.field_const(0).as_basic_value_enum()),
+    }
+}
+
+/// Translates the return data copy.
+pub fn copy<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    destination_offset: inkwell::values::IntValue<'ctx>,
+    source_offset: inkwell::values::IntValue<'ctx>,
+    size: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let error_block = context.append_basic_block("return_data_copy_error_block");
+    let join_block = context.append_basic_block("return_data_copy_join_block");
+
+    let return_data_size = self::size(context)?.into_int_value();
+    let copy_slice_end =
+        context
+            .builder()
+            .build_int_add(source_offset, size, "return_data_copy_slice_end")?;
+    let is_copy_out_of_bounds = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        copy_slice_end,
+        return_data_size,
+        "return_data_copy_is_out_of_bounds",
+    )?;
+    context.build_conditional_branch(is_copy_out_of_bounds, error_block, join_block)?;
+
+    context.set_basic_block(error_block);
+    crate::polkavm::evm::r#return::revert(context, context.field_const(0), context.field_const(0))?;
+
+    context.set_basic_block(join_block);
+    let destination = Pointer::new_with_offset(
+        context,
+        AddressSpace::Heap,
+        context.byte_type(),
+        destination_offset,
+        "return_data_copy_destination_pointer",
+    );
+
+    let return_data_pointer_global =
+        context.get_global(crate::polkavm::GLOBAL_RETURN_DATA_POINTER)?;
+    let return_data_pointer_pointer = return_data_pointer_global.into();
+    let return_data_pointer =
+        context.build_load(return_data_pointer_pointer, "return_data_pointer")?;
+    let source = context.build_gep(
+        Pointer::new(
+            context.byte_type(),
+            return_data_pointer_pointer.address_space,
+            return_data_pointer.into_pointer_value(),
+        ),
+        &[source_offset],
+        context.byte_type().as_basic_type_enum(),
+        "return_data_source_pointer",
+    );
+
+    context.build_memcpy(
+        context.intrinsics().memory_copy_from_generic,
+        destination,
+        source,
+        size,
+        "return_data_copy_memcpy_from_return_data",
+    )?;
+
+    todo!("Build heap GEP to allocate if necessary")
+}

crates/llvm-context/src/polkavm/evm/storage.rs

@@ -0,0 +1,82 @@
+//! Translates the storage operations.
+
+use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+
+/// Translates the storage load.
+pub fn load<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    position: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let position_pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::Storage,
+        context.field_type(),
+        position,
+        "storage_load_position_pointer",
+    );
+    context.build_load(position_pointer, "storage_load_value")
+}
+
+/// Translates the storage store.
+pub fn store<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    position: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let position_pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::Storage,
+        context.field_type(),
+        position,
+        "storage_store_position_pointer",
+    );
+    context.build_store(position_pointer, value)?;
+    Ok(())
+}
+
+/// Translates the transient storage load.
+pub fn transient_load<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    position: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+where
+    D: Dependency + Clone,
+{
+    let position_pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::TransientStorage,
+        context.field_type(),
+        position,
+        "transient_storage_load_position_pointer",
+    );
+    context.build_load(position_pointer, "transient_storage_load_value")
+}
+
+/// Translates the transient storage store.
+pub fn transient_store<'ctx, D>(
+    context: &mut Context<'ctx, D>,
+    position: inkwell::values::IntValue<'ctx>,
+    value: inkwell::values::IntValue<'ctx>,
+) -> anyhow::Result<()>
+where
+    D: Dependency + Clone,
+{
+    let position_pointer = Pointer::new_with_offset(
+        context,
+        AddressSpace::TransientStorage,
+        context.field_type(),
+        position,
+        "transient_storage_store_position_pointer",
+    );
+    context.build_store(position_pointer, value)?;
+    Ok(())
+}