Updated call semantics (#56)

- Update pallet-revive dependency
- Implement calls according to pallet-revive call semantics
- Switch to the new return data API in pallet revive and get rid of return data buffer
- Remove a bunch of resulting dead code

crates/llvm-context/src/polkavm/context/function/runtime/entry.rs

@@ -1,7 +1,6 @@
 //! The entry function.
 
 use inkwell::types::BasicType;
-use inkwell::values::BasicValue;
 
 use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::function::runtime;
@@ -26,9 +25,6 @@ impl Entry {
     /// Reserve 1kb for calldata.
     pub const MAX_CALLDATA_SIZE: usize = 1024;
 
-    /// Reserve 1kb for returndata.
-    pub const MAX_RETURNDATA_SIZE: usize = 1024;
-
     /// Initializes the global variables.
     /// The pointers are not initialized, because it's not possible to create a null pointer.
     pub fn initialize_globals<D>(context: &mut Context<D>) -> anyhow::Result<()>
@@ -43,14 +39,6 @@ impl Entry {
             calldata_type.get_undef(),
         );
 
-        let returndata_type = context.array_type(context.byte_type(), Self::MAX_RETURNDATA_SIZE);
-        context.set_global(
-            crate::polkavm::GLOBAL_RETURN_DATA_POINTER,
-            returndata_type,
-            AddressSpace::Stack,
-            returndata_type.get_undef(),
-        );
-
         context.set_global(
             crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER,
             context.llvm().ptr_type(AddressSpace::Heap.into()),
@@ -70,12 +58,6 @@ impl Entry {
             AddressSpace::Stack,
             context.word_undef(),
         );
-        context.set_global(
-            crate::polkavm::GLOBAL_RETURN_DATA_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.xlen_type().const_zero().as_basic_value_enum(),
-        );
 
         context.set_global(
             crate::polkavm::GLOBAL_CALL_FLAGS,
@@ -84,33 +66,6 @@ impl Entry {
             context.word_const(0),
         );
 
-        context.set_global(
-            crate::polkavm::GLOBAL_I256_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(
-                crate::polkavm::XLEN,
-                revive_common::BYTE_LENGTH_X64 as u64 * 4,
-            ),
-        );
-
-        context.set_global(
-            crate::polkavm::GLOBAL_I160_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(
-                crate::polkavm::XLEN,
-                revive_common::BYTE_LENGTH_X64 as u64 * 2 + revive_common::BYTE_LENGTH_X32 as u64,
-            ),
-        );
-
-        context.set_global(
-            crate::polkavm::GLOBAL_I64_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(crate::polkavm::XLEN, revive_common::BYTE_LENGTH_X64 as u64),
-        );
-
         Ok(())
     }
 

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

@@ -610,9 +610,8 @@ where
         }
 
         let pointer = self.build_alloca(r#type, name);
-
         self.set_basic_block(current_block);
-        return pointer;
+        pointer
     }
 
     /// Builds an aligned stack allocation at the current position.
@@ -633,43 +632,16 @@ where
         Pointer::new(r#type, AddressSpace::Stack, pointer)
     }
 
-    /// Allocate an int of size `bit_length` on the stack.
-    /// Returns the allocation pointer and the length pointer.
-    ///
-    /// Useful helper for passing runtime API parameters on the stack.
-    pub fn build_stack_parameter(
-        &self,
-        bit_length: usize,
-        name: &str,
-    ) -> (Pointer<'ctx>, Pointer<'ctx>) {
-        let buffer_pointer = self.build_alloca(self.integer_type(bit_length), name);
-        let symbol = match bit_length {
-            revive_common::BIT_LENGTH_WORD => GLOBAL_I256_SIZE,
-            revive_common::BIT_LENGTH_ETH_ADDRESS => GLOBAL_I160_SIZE,
-            revive_common::BIT_LENGTH_BLOCK_NUMBER => GLOBAL_I64_SIZE,
-            _ => panic!("invalid stack parameter bit width: {bit_length}"),
-        };
-        let length_pointer = self.get_global(symbol).expect("should be declared");
-        (buffer_pointer, length_pointer.into())
-    }
-
-    /// Load the integer at given pointer and zero extend it to the VM word size.
-    pub fn build_load_word(
+    /// Load the address at given pointer and zero extend it to the VM word size.
+    pub fn build_load_address(
         &self,
         pointer: Pointer<'ctx>,
-        bit_length: usize,
-        name: &str,
     ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>> {
-        let value = self.build_load(
-            pointer.cast(self.integer_type(bit_length)),
-            &format!("load_{name}"),
-        )?;
-        let value_extended = self.builder().build_int_z_extend(
-            value.into_int_value(),
-            self.word_type(),
-            &format!("zext_{name}"),
-        )?;
-        Ok(value_extended.as_basic_value_enum())
+        let address = self.build_byte_swap(self.build_load(pointer, "address_pointer")?)?;
+        Ok(self
+            .builder()
+            .build_int_z_extend(address.into_int_value(), self.word_type(), "address_zext")?
+            .into())
     }
 
     /// Builds a stack load instruction.