llvm-context: lazy handling of function arguments and immutable data (#282)

- Lazily load function arguments so that they can be passed as pointers.
- Lazily call the immutable store function to avoid storing zero sized
immutable data.

---------

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>

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

@@ -119,10 +119,8 @@ where
                 _ => error,
             })?;
     if contract_path.as_str() == parent {
-        return Ok(Argument::new_with_constant(
-            context.word_const(0).as_basic_value_enum(),
-            num::BigUint::zero(),
-        ));
+        return Ok(Argument::value(context.word_const(0).as_basic_value_enum())
+            .with_constant(num::BigUint::zero()));
     } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
         anyhow::bail!("type({}).runtimeCode is not supported", identifier);
     }
@@ -131,7 +129,7 @@ where
     let hash_value = context
         .word_const_str_hex(hash_string.as_str())
         .as_basic_value_enum();
-    Ok(Argument::new_with_original(hash_value, hash_string))
+    Ok(Argument::value(hash_value).with_original(hash_string))
 }
 
 /// Translates the deploy call header size instruction. the header consists of
@@ -160,10 +158,8 @@ where
                 _ => error,
             })?;
     if contract_path.as_str() == parent {
-        return Ok(Argument::new_with_constant(
-            context.word_const(0).as_basic_value_enum(),
-            num::BigUint::zero(),
-        ));
+        return Ok(Argument::value(context.word_const(0).as_basic_value_enum())
+            .with_constant(num::BigUint::zero()));
     } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
         anyhow::bail!("type({}).runtimeCode is not supported", identifier);
     }
@@ -172,5 +168,5 @@ where
     let size_value = context
         .word_const(crate::polkavm::DEPLOYER_CALL_HEADER_SIZE as u64)
         .as_basic_value_enum();
-    Ok(Argument::new_with_constant(size_value, size_bigint))
+    Ok(Argument::value(size_value).with_constant(size_bigint))
 }

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

@@ -257,6 +257,7 @@ where
             anyhow::bail!("Immutables are not available if the contract part is undefined");
         }
         Some(CodeType::Deploy) => {
+            context.enable_immutables();
             let immutable_data_pointer = context
                 .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
                 .value

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

@@ -18,11 +18,13 @@ where
     match context.code_type() {
         None => anyhow::bail!("Return is not available if the contract part is undefined"),
         Some(CodeType::Deploy) => {
-            context.build_call(
-                <Store as RuntimeFunction<D>>::declaration(context),
-                Default::default(),
-                "store_immutable_data",
-            );
+            if context.has_immutables() {
+                context.build_call(
+                    <Store as RuntimeFunction<D>>::declaration(context),
+                    Default::default(),
+                    "store_immutable_data",
+                );
+            }
         }
         Some(CodeType::Runtime) => {}
     }

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

@@ -3,6 +3,7 @@
 use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::PolkaVMArgument;
 use crate::PolkaVMLoadStorageWordFunction;
 use crate::PolkaVMLoadTransientStorageWordFunction;
 use crate::PolkaVMStoreStorageWordFunction;
@@ -11,14 +12,14 @@ use crate::PolkaVMStoreTransientStorageWordFunction;
 /// Translates the storage load.
 pub fn load<'ctx, D>(
     context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
     D: Dependency + Clone,
 {
     let name = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::NAME;
     let declaration = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into()];
+    let arguments = [position.as_pointer(context)?.value.into()];
     Ok(context
         .build_call(declaration, &arguments, "storage_load")
         .unwrap_or_else(|| panic!("runtime function {name} should return a value")))
@@ -27,14 +28,17 @@ where
 /// Translates the storage store.
 pub fn store<'ctx, D>(
     context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
+    value: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<()>
 where
     D: Dependency + Clone,
 {
     let declaration = <PolkaVMStoreStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into(), value.into()];
+    let arguments = [
+        position.as_pointer(context)?.value.into(),
+        value.as_pointer(context)?.value.into(),
+    ];
     context.build_call(declaration, &arguments, "storage_store");
     Ok(())
 }
@@ -42,13 +46,13 @@ where
 /// Translates the transient storage load.
 pub fn transient_load<'ctx, D>(
     context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
     D: Dependency + Clone,
 {
     let name = <PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::NAME;
-    let arguments = [position.into()];
+    let arguments = [position.as_pointer(context)?.value.into()];
     let declaration =
         <PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
@@ -59,15 +63,18 @@ where
 /// 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>,
+    position: &PolkaVMArgument<'ctx>,
+    value: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<()>
 where
     D: Dependency + Clone,
 {
     let declaration =
         <PolkaVMStoreTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into(), value.into()];
+    let arguments = [
+        position.as_pointer(context)?.value.into(),
+        value.as_pointer(context)?.value.into(),
+    ];
     context.build_call(declaration, &arguments, "transient_storage_store");
     Ok(())
 }