Soroban: support dynamic memory arrays (#1838)

This PR adds support for dynamic memory arrays is Soroban's Solidity.
Namely, this example:
http://github.com/stellar/soroban-examples/blob/main/alloc/src/lib.rs

Under the hood, the example above uses a custom no-free bump allocator,
written in Rust and linked with Soroban contracts:
https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/src/alloc.rs#L5

We followed the same approach, but wrote it in C instead. The reason for
opting for C instead of Rust is that it fits well with Solang's
compiling and linking pipeline.

---------

Signed-off-by: salaheldinsoliman <[email protected]>

Author: salaheldinsoliman

src/codegen/encoding/soroban_encoding.rs

@@ -31,7 +31,7 @@ pub fn soroban_encode(
 
     let size_expr = Expression::NumberLiteral {
         loc: *loc,
-        ty: Uint(64),
+        ty: Uint(32),
         value: size.into(),
     };
     let encoded_bytes = vartab.temp_name("abi_encoded", &Type::Bytes(size as u8));
@@ -40,7 +40,7 @@ pub fn soroban_encode(
         loc: *loc,
         ty: Type::Bytes(size as u8),
         size: size_expr.clone().into(),
-        initializer: Some(vec![]),
+        initializer: None,
     };
 
     cfg.add(
@@ -323,6 +323,8 @@ pub fn soroban_encode_arg(
                     _ => unreachable!(),
                 };
 
+                println!("encoded: {:?}, len: {:?}", encoded, len);
+
                 Instr::Call {
                     res: vec![obj],
                     return_tys: vec![Type::Uint(64)],

src/emit/binary.rs

@@ -292,6 +292,27 @@ impl<'a> Binary<'a> {
         export_list.push("__lshrti3");
         export_list.push("__ashrti3");
 
+        if self.ns.target == crate::Target::Soroban {
+            let mut f = self.module.get_first_function();
+            while let Some(func) = f {
+                let name = func.get_name().to_str().unwrap();
+                // leave LLVM intrinsics alone
+                if name.starts_with("llvm.") {
+                    f = func.get_next_function();
+                    continue;
+                }
+
+                if export_list.contains(&name) {
+                    func.set_linkage(inkwell::module::Linkage::External);
+                } else {
+                    func.set_linkage(inkwell::module::Linkage::Internal);
+                }
+
+                f = func.get_next_function();
+            }
+            return;
+        }
+
         while let Some(f) = func {
             let name = f.get_name().to_str().unwrap();
 
@@ -1036,71 +1057,7 @@ impl<'a> Binary<'a> {
         size: IntValue<'a>,
         elem_size: IntValue<'a>,
         init: Option<&Vec<u8>>,
-        ty: &Type,
     ) -> BasicValueEnum<'a> {
-        if self.ns.target == Target::Soroban {
-            if matches!(ty, Type::Bytes(_)) {
-                let n = if let Type::Bytes(n) = ty {
-                    n
-                } else {
-                    unreachable!()
-                };
-
-                let data = self
-                    .builder
-                    .build_alloca(self.context.i64_type().array_type((*n / 8) as u32), "data")
-                    .unwrap();
-
-                let ty = self.context.struct_type(
-                    &[data.get_type().into(), self.context.i64_type().into()],
-                    false,
-                );
-
-                // Start with an undefined struct value
-                let mut struct_value = ty.get_undef();
-
-                // Insert `data` into the first field of the struct
-                struct_value = self
-                    .builder
-                    .build_insert_value(struct_value, data, 0, "insert_data")
-                    .unwrap()
-                    .into_struct_value();
-
-                // Insert `size` into the second field of the struct
-                struct_value = self
-                    .builder
-                    .build_insert_value(struct_value, size, 1, "insert_size")
-                    .unwrap()
-                    .into_struct_value();
-
-                // Return the constructed struct value
-                return struct_value.into();
-            } else if matches!(ty, Type::String) {
-                let default = " ".as_bytes().to_vec();
-                let bs = init.unwrap_or(&default);
-
-                let data = self.emit_global_string("const_string", bs, true);
-
-                // A constant string, or array, is represented by a struct with two fields: a pointer to the data, and its length.
-                let ty = self.context.struct_type(
-                    &[
-                        self.context.ptr_type(AddressSpace::default()).into(),
-                        self.context.i64_type().into(),
-                    ],
-                    false,
-                );
-
-                return ty
-                    .const_named_struct(&[
-                        data.into(),
-                        self.context
-                            .i64_type()
-                            .const_int(bs.len() as u64, false)
-                            .into(),
-                    ])
-                    .as_basic_value_enum();
-            }
-        }
         if let Some(init) = init {
             if init.is_empty() {
                 return self
@@ -1116,16 +1073,22 @@ impl<'a> Binary<'a> {
             Some(s) => self.emit_global_string("const_string", s, true),
         };
 
-        self.builder
-            .build_call(
+        println!("calling soroban alloc : {:?}", size);
+        let allocator = if self.ns.target == Target::Soroban {
+            self.builder.build_call(
+                self.module.get_function("soroban_alloc_init").unwrap(),
+                &[size.into(), init.into()],
+                "soroban_alloc",
+            )
+        } else {
+            self.builder.build_call(
                 self.module.get_function("vector_new").unwrap(),
                 &[size.into(), elem_size.into(), init.into()],
-                "",
+                "vector_new",
             )
-            .unwrap()
-            .try_as_basic_value()
-            .left()
-            .unwrap()
+        };
+
+        allocator.unwrap().try_as_basic_value().left().unwrap()
     }
 
     /// Number of element in a vector
@@ -1134,19 +1097,19 @@ impl<'a> Binary<'a> {
             // slice
             let slice = vector.into_struct_value();
 
-            let len_type = if self.ns.target == Target::Soroban {
+            /*let len_type = if self.ns.target == Target::Soroban {
                 self.context.i64_type()
             } else {
                 self.context.i32_type()
-            };
+            };*/
 
             self.builder
                 .build_int_truncate(
                     self.builder
                         .build_extract_value(slice, 1, "slice_len")
                         .unwrap()
                         .into_int_value(),
-                    len_type,
+                    self.context.i32_type(),
                     "len",
                 )
                 .unwrap()
@@ -1376,11 +1339,12 @@ static BPF_IR: [&[u8]; 6] = [
     include_bytes!("../../target/bpf/heap.bc"),
 ];
 
-static WASM_IR: [&[u8]; 4] = [
+static WASM_IR: [&[u8]; 5] = [
     include_bytes!("../../target/wasm/stdlib.bc"),
     include_bytes!("../../target/wasm/heap.bc"),
     include_bytes!("../../target/wasm/bigint.bc"),
     include_bytes!("../../target/wasm/format.bc"),
+    include_bytes!("../../target/wasm/soroban.bc"),
 ];
 
 static RIPEMD160_IR: &[u8] = include_bytes!("../../target/wasm/ripemd160.bc");

src/emit/expression.rs

@@ -128,6 +128,7 @@ pub(super) fn expression<'a, T: TargetRuntime<'a> + ?Sized>(
             s.into()
         }
         Expression::BytesLiteral { value: bs, ty, .. } => {
+            println!("BytesLiteral: {:?} and ty {:?}", bs, ty);
             // If the type of a BytesLiteral is a String, embedd the bytes in the binary.
             if ty == &Type::String || ty == &Type::Address(true) {
                 let data = bin.emit_global_string("const_string", bs, true);
@@ -1580,7 +1581,7 @@ pub(super) fn expression<'a, T: TargetRuntime<'a> + ?Sized>(
                     .unwrap()
                     .const_cast(bin.context.i32_type(), false);
 
-                bin.vector_new(size, elem_size, initializer.as_ref(), ty)
+                bin.vector_new(size, elem_size, initializer.as_ref())
             }
         }
         Expression::Builtin {

src/emit/instructions.rs

@@ -211,11 +211,16 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
             let size = bin.builder.build_int_mul(elem_size, new_len, "").unwrap();
             let size = bin.builder.build_int_add(size, vec_size, "").unwrap();
 
+            let allocator = if bin.ns.target == Target::Soroban {
+                "soroban_realloc"
+            } else {
+                "__realloc"
+            };
             // Reallocate and reassign the array pointer
             let new = bin
                 .builder
                 .build_call(
-                    bin.module.get_function("__realloc").unwrap(),
+                    bin.module.get_function(allocator).unwrap(),
                     &[arr.into(), size.into()],
                     "",
                 )
@@ -382,11 +387,16 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
                 w.vars.get_mut(res).unwrap().value = ret_val;
             }
 
+            let allocator = if bin.ns.target == Target::Soroban {
+                "soroban_realloc"
+            } else {
+                "__realloc"
+            };
             // Reallocate and reassign the array pointer
             let new = bin
                 .builder
                 .build_call(
-                    bin.module.get_function("__realloc").unwrap(),
+                    bin.module.get_function(allocator).unwrap(),
                     &[a.into(), size.into()],
                     "",
                 )

src/emit/solana/target.rs

@@ -749,9 +749,7 @@ impl<'a> TargetRuntime<'a> for SolanaTarget {
                         .unwrap()
                         .into_int_value();
 
-                    dest = bin
-                        .vector_new(length, elem_size, None, elem_ty)
-                        .into_pointer_value();
+                    dest = bin.vector_new(length, elem_size, None).into_pointer_value();
                 };
 
                 let elem_size = elem_ty.solana_storage_size(bin.ns).to_u64().unwrap();

src/emit/soroban/target.rs

@@ -345,33 +345,28 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
     /// Prints a string
     /// TODO: Implement this function, with a call to the `log` function in the Soroban runtime.
     fn print(&self, bin: &Binary, string: PointerValue, length: IntValue) {
-        if string.is_const() && length.is_const() {
-            let msg_pos = bin
-                .builder
-                .build_ptr_to_int(string, bin.context.i64_type(), "msg_pos")
-                .unwrap();
-            let length = length.const_cast(bin.context.i64_type(), false);
+        let msg_pos = bin
+            .builder
+            .build_ptr_to_int(string, bin.context.i64_type(), "msg_pos")
+            .unwrap();
 
-            let msg_pos_encoded = encode_value(msg_pos, 32, 4, bin);
-            let length_encoded = encode_value(length, 32, 4, bin);
+        let msg_pos_encoded = encode_value(msg_pos, 32, 4, bin);
+        let length_encoded = encode_value(length, 32, 4, bin);
 
-            bin.builder
-                .build_call(
-                    bin.module
-                        .get_function(HostFunctions::LogFromLinearMemory.name())
-                        .unwrap(),
-                    &[
-                        msg_pos_encoded.into(),
-                        length_encoded.into(),
-                        msg_pos_encoded.into(),
-                        encode_value(bin.context.i64_type().const_zero(), 32, 4, bin).into(),
-                    ],
-                    "log",
-                )
-                .unwrap();
-        } else {
-            todo!("Dynamic String printing is not yet supported")
-        }
+        bin.builder
+            .build_call(
+                bin.module
+                    .get_function(HostFunctions::LogFromLinearMemory.name())
+                    .unwrap(),
+                &[
+                    msg_pos_encoded.into(),
+                    length_encoded.into(),
+                    msg_pos_encoded.into(),
+                    encode_value(bin.context.i64_type().const_zero(), 32, 4, bin).into(),
+                ],
+                "log",
+            )
+            .unwrap();
     }
 
     /// Return success without any result
@@ -452,7 +447,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
             .builder
             .build_int_unsigned_div(
                 payload_len,
-                bin.context.i64_type().const_int(8, false),
+                payload_len.get_type().const_int(8, false),
                 "args_len",
             )
             .unwrap();
@@ -461,7 +456,7 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
             .builder
             .build_int_sub(
                 args_len,
-                bin.context.i64_type().const_int(1, false),
+                args_len.get_type().const_int(1, false),
                 "args_len",
             )
             .unwrap();
@@ -756,7 +751,25 @@ fn storage_type_to_int(storage_type: &Option<StorageType>) -> u64 {
     }
 }
 
-fn encode_value<'a>(value: IntValue<'a>, shift: u64, add: u64, bin: &'a Binary) -> IntValue<'a> {
+fn encode_value<'a>(
+    mut value: IntValue<'a>,
+    shift: u64,
+    add: u64,
+    bin: &'a Binary,
+) -> IntValue<'a> {
+    match value.get_type().get_bit_width() {
+        32 =>
+        // extend to 64 bits
+        {
+            value = bin
+                .builder
+                .build_int_z_extend(value, bin.context.i64_type(), "temp")
+                .unwrap();
+        }
+        64 => (),
+        _ => unreachable!(),
+    }
+
     let shifted = bin
         .builder
         .build_left_shift(
@@ -765,6 +778,7 @@ fn encode_value<'a>(value: IntValue<'a>, shift: u64, add: u64, bin: &'a Binary)
             "temp",
         )
         .unwrap();
+
     bin.builder
         .build_int_add(
             shifted,

src/emit/strings.rs

@@ -95,12 +95,7 @@ pub(super) fn format_string<'a, T: TargetRuntime<'a> + ?Sized>(
 
     // allocate the string and
     let vector = bin
-        .vector_new(
-            length,
-            bin.context.i32_type().const_int(1, false),
-            None,
-            &Type::String,
-        )
+        .vector_new(length, bin.context.i32_type().const_int(1, false), None)
         .into_pointer_value();
 
     let output_start = bin.vector_bytes(vector.into());