internalize register size

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

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

@@ -50,7 +50,7 @@ impl Entry {
             context
                 .get_global(crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER)?
                 .into(),
-            context.build_sbrk(context.integer_const(32, 0))?,
+            context.build_sbrk(context.integer_const(crate::polkavm::XLEN, 0))?,
         )?;
 
         context.set_global(
@@ -112,7 +112,7 @@ impl Entry {
 
         context.build_store(
             length_pointer,
-            context.integer_const(32, Self::MAX_CALLDATA_SIZE as u64),
+            context.integer_const(crate::polkavm::XLEN, Self::MAX_CALLDATA_SIZE as u64),
         )?;
         context.build_runtime_call(
             runtime_api::INPUT,

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

@@ -677,14 +677,17 @@ where
                     .build_store(storage_key_pointer.value, storage_key_value)?;
                 self.builder().build_store(
                     storage_value_length_pointer.value,
-                    self.integer_const(32, revive_common::BIT_LENGTH_FIELD as u64),
+                    self.integer_const(
+                        crate::polkavm::XLEN,
+                        revive_common::BIT_LENGTH_FIELD as u64,
+                    ),
                 )?;
 
                 self.build_runtime_call(
                     runtime_api::GET_STORAGE,
                     &[
                         storage_key_pointer_casted.into(),
-                        self.integer_const(32, 32).into(),
+                        self.integer_const(crate::polkavm::XLEN, 32).into(),
                         storage_value_pointer_casted.into(),
                         storage_value_length_pointer_casted.into(),
                     ],
@@ -788,9 +791,9 @@ where
                     runtime_api::SET_STORAGE,
                     &[
                         storage_key_pointer_casted.into(),
-                        self.integer_const(32, 32).into(),
+                        self.integer_const(crate::polkavm::XLEN, 32).into(),
                         storage_value_pointer_casted.into(),
-                        self.integer_const(32, 32).into(),
+                        self.integer_const(crate::polkavm::XLEN, 32).into(),
                     ],
                 );
             }
@@ -1124,11 +1127,11 @@ where
         //    zkevm_opcode_defs::RetForwardPageType::UseHeap
         //};
 
-        let offset_truncated = self.safe_truncate_int_to_i32(offset)?;
+        let offset_truncated = self.safe_truncate_int_to_xlen(offset)?;
-        let length_truncated = self.safe_truncate_int_to_i32(length)?;
+        let length_truncated = self.safe_truncate_int_to_xlen(length)?;
         let offset_into_heap = self.build_heap_gep(offset_truncated, length_truncated)?;
 
-        let length_pointer = self.safe_truncate_int_to_i32(length)?;
+        let length_pointer = self.safe_truncate_int_to_xlen(length)?;
         let offset_pointer = self.builder().build_ptr_to_int(
             offset_into_heap.value,
             self.xlen_type(),
@@ -1144,11 +1147,11 @@ where
         Ok(())
     }
 
-    /// Truncate a memory offset into 32 bits, trapping if it doesn't fit.
+    /// Truncate a memory offset to register size, trapping if it doesn't fit.
     /// Pointers are represented as opaque 256 bit integer values in EVM.
-    /// In practice, they should never exceed a 32 bit value. However, we
+    /// In practice, they should never exceed a register sized bit value.
-    /// still protect against this possibility here.
+    /// However, we still protect against this possibility here.
-    pub fn safe_truncate_int_to_i32(
+    pub fn safe_truncate_int_to_xlen(
         &self,
         value: inkwell::values::IntValue<'ctx>,
     ) -> anyhow::Result<inkwell::values::IntValue<'ctx>> {
@@ -1230,7 +1233,7 @@ where
     /// Returns a pointer to `offset` into the heap, allocating
     /// enough memory if `offset + length` would be out of bounds.
     /// # Panics
-    /// Assumes `offset` and `length` to be an i32 value.
+    /// Assumes `offset` and `length` to be a register sized value.
     pub fn build_heap_gep(
         &self,
         offset: inkwell::values::IntValue<'ctx>,
@@ -1243,7 +1246,7 @@ where
             .get_global(crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER)?
             .value
             .as_pointer_value();
-        let heap_end = self.build_sbrk(self.integer_const(32, 0))?;
+        let heap_end = self.build_sbrk(self.integer_const(crate::polkavm::XLEN, 0))?;
         let value_end = self.build_gep(
             Pointer::new(self.byte_type(), AddressSpace::Stack, heap_start),
             &[self.builder().build_int_nuw_add(offset, length, "end")?],

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

@@ -68,7 +68,7 @@ impl<'ctx> Pointer<'ctx> {
             "Stack pointers cannot be addressed"
         );
 
-        let offset = context.safe_truncate_int_to_i32(offset).unwrap();
+        let offset = context.safe_truncate_int_to_xlen(offset).unwrap();
         let value = context
             .builder
             .build_int_to_ptr(offset, context.llvm().ptr_type(address_space.into()), name)

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

@@ -51,8 +51,8 @@ pub fn copy<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let offset = context.safe_truncate_int_to_i32(destination_offset)?;
+    let offset = context.safe_truncate_int_to_xlen(destination_offset)?;
-    let size = context.safe_truncate_int_to_i32(size)?;
+    let size = context.safe_truncate_int_to_xlen(size)?;
     let destination = context.build_heap_gep(offset, size)?;
 
     let calldata_pointer = context
@@ -61,7 +61,7 @@ where
         .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.safe_truncate_int_to_xlen(source_offset)?],
         context.byte_type(),
         "calldata_pointer_with_offset",
     );

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

@@ -13,8 +13,8 @@ pub fn sha3<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let offset_casted = context.safe_truncate_int_to_i32(offset)?;
+    let offset_casted = context.safe_truncate_int_to_xlen(offset)?;
-    let length_casted = context.safe_truncate_int_to_i32(length)?;
+    let length_casted = context.safe_truncate_int_to_xlen(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,

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

@@ -61,13 +61,17 @@ where
             )?;
 
             context.build_exit(
-                context.integer_const(32, 0),
+                context.integer_const(crate::polkavm::XLEN, 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)?;
+            context.build_exit(
+                context.integer_const(crate::polkavm::XLEN, 0),
+                offset,
+                length,
+            )?;
         }
     }
 
@@ -83,7 +87,11 @@ pub fn revert<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    context.build_exit(context.integer_const(32, 1), offset, length)
+    context.build_exit(
+        context.integer_const(crate::polkavm::XLEN, 1),
+        offset,
+        length,
+    )
 }
 
 /// Translates the `stop` instruction.
@@ -94,8 +102,8 @@ where
 {
     r#return(
         context,
-        context.integer_const(32, 0),
+        context.integer_const(crate::polkavm::XLEN, 0),
-        context.integer_const(32, 0),
+        context.integer_const(crate::polkavm::XLEN, 0),
     )
 }