print runtime errors working

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

Author: salaheldinsoliman

src/codegen/dispatch/soroban.rs

@@ -102,6 +102,11 @@ pub fn function_dispatch(
 
         wrapper_cfg.add(&mut vartab, placeholder);
 
+<<<<<<< HEAD
+        
+        if value.len() == 1 {
+=======
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
         // set the msb 8 bits of the return value to 6, the return value is 64 bits.
         // FIXME: this assumes that the solidity function always returns one value.
         let shifted = Expression::ShiftLeft {
@@ -131,6 +136,21 @@ pub fn function_dispatch(
         };
 
         wrapper_cfg.add(&mut vartab, Instr::Return { value: vec![added] });
+<<<<<<< HEAD
+    } else {
+
+        // return 2 as numberliteral
+        let two = Expression::NumberLiteral {
+            loc: pt::Loc::Codegen,
+            ty: Type::Uint(64),
+            value: BigInt::from(2_u64),
+        };
+
+        wrapper_cfg.add(&mut vartab, Instr::Return { value: vec![two] });
+    }
+
+=======
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
 
         vartab.finalize(ns, &mut wrapper_cfg);
         cfg.public = false;

src/emit/soroban/mod.rs

@@ -22,6 +22,10 @@ use std::sync;
 const SOROBAN_ENV_INTERFACE_VERSION: u64 = 90194313216;
 pub const PUT_CONTRACT_DATA: &str = "l._";
 pub const GET_CONTRACT_DATA: &str = "l.1";
+<<<<<<< HEAD
+pub const LOG_FROM_LINEAR_MEMORY: &str = "x._";
+=======
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
 
 pub struct SorobanTarget;
 
@@ -231,12 +235,27 @@ impl SorobanTarget {
             .i64_type()
             .fn_type(&[ty.into(), ty.into()], false);
 
+<<<<<<< HEAD
+        let log_function_ty = binary
+            .context
+            .i64_type()
+            .fn_type(&[ty.into(), ty.into(), ty.into(), ty.into()], false);
+
+=======
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
         binary
             .module
             .add_function(PUT_CONTRACT_DATA, function_ty_1, Some(Linkage::External));
         binary
             .module
             .add_function(GET_CONTRACT_DATA, function_ty, Some(Linkage::External));
+<<<<<<< HEAD
+
+        binary
+            .module
+            .add_function(LOG_FROM_LINEAR_MEMORY, log_function_ty, Some(Linkage::External));
+=======
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
     }
 
     fn emit_initializer(binary: &mut Binary, _ns: &ast::Namespace) {

src/emit/soroban/target.rs

@@ -2,8 +2,13 @@
 
 use crate::codegen::cfg::HashTy;
 use crate::codegen::Expression;
+<<<<<<< HEAD
+use crate::emit::binary::{self, Binary};
+use crate::emit::soroban::{SorobanTarget, GET_CONTRACT_DATA, LOG_FROM_LINEAR_MEMORY, PUT_CONTRACT_DATA};
+=======
 use crate::emit::binary::Binary;
 use crate::emit::soroban::{SorobanTarget, GET_CONTRACT_DATA, PUT_CONTRACT_DATA};
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
 use crate::emit::ContractArgs;
 use crate::emit::{TargetRuntime, Variable};
 use crate::emit_context;
@@ -13,10 +18,17 @@ use crate::sema::ast::{Function, Namespace, Type};
 
 use inkwell::types::{BasicTypeEnum, IntType};
 use inkwell::values::{
+<<<<<<< HEAD
+    AnyValue, ArrayValue, AsValueRef, BasicMetadataValueEnum, BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue
+};
+
+use inkwell::AddressSpace;
+=======
     ArrayValue, BasicMetadataValueEnum, BasicValue, BasicValueEnum, FunctionValue, IntValue,
     PointerValue,
 };
 
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
 use solang_parser::pt::Loc;
 
 use std::collections::HashMap;
@@ -236,7 +248,76 @@ impl<'a> TargetRuntime<'a> for SorobanTarget {
 
     /// Prints a string
     /// TODO: Implement this function, with a call to the `log` function in the Soroban runtime.
+<<<<<<< HEAD
+    fn print(&self, bin: &Binary, string: PointerValue, length: IntValue) {
+
+
+
+       let mut toprint;
+        unsafe {
+        toprint = string.as_value_ref().offset(0);
+        println!( "TO PRINT! {:?}", toprint);
+        }
+        //println!("print called with string: {:?} ", string.as_value_ref());
+        println!("msg_pos: {:?}", string);
+        println!("length: {:?}", length);
+
+        let msg_pos = bin.builder.build_ptr_to_int(string, bin.context.i64_type(), "msg_pos").unwrap();
+
+        let msg_pos = msg_pos.const_cast(bin.context.i64_type(), false);
+
+        
+
+        println!("msg_pos extracted: {:?}", msg_pos);
+        println!("=============================================================");
+
+
+        
+
+        //let length = bin.context.i64_type().const_int(1024, false);
+
+        let length = length.const_cast(bin.context.i64_type(), false);
+
+       
+        let eight = bin.context.i64_type().const_int(8, false);
+        let four = bin.context.i64_type().const_int(4, false);
+        let zero = bin.context.i64_type().const_int(0, false);
+        let thirty_two = bin.context.i64_type().const_int(32, false);
+
+        // encode msg_pos and length
+        let msg_pos_encoded = bin.builder.build_left_shift(msg_pos, thirty_two, "temp").unwrap();
+        let msg_pos_encoded = bin.builder.build_int_add(msg_pos_encoded, four, "msg_pos_encoded").unwrap();
+
+
+
+        let length_encoded = bin.builder.build_left_shift(length, thirty_two, "temp").unwrap();
+        let length_encoded = bin.builder.build_int_add(length_encoded, four, "length_encoded").unwrap();
+
+
+        let zero_encoded = bin.builder.build_left_shift(zero, eight, "temp").unwrap();
+        
+
+        let eight_encoded = bin.builder.build_left_shift(eight, eight, "temp").unwrap();
+        let eight_encoded = bin.builder.build_int_add(eight_encoded, four, "eight_encoded").unwrap();
+
+
+
+
+        let call_res = bin.builder.build_call(
+            bin.module.get_function(LOG_FROM_LINEAR_MEMORY).unwrap(),
+            &[
+                msg_pos_encoded.into(),
+                length_encoded.into(),
+                msg_pos_encoded.into(),
+                four.into(),
+            ],
+            "log",
+        ).unwrap();
+
+    }
+=======
     fn print(&self, bin: &Binary, string: PointerValue, length: IntValue) {}
+>>>>>>> 06798cdeac6fd62ee98f5ae7da38f3af4933dc0f
 
     /// Return success without any result
     fn return_empty_abi(&self, bin: &Binary) {

src/linker/soroban_wasm.rs

@@ -11,8 +11,7 @@ use wasm_encoder::{
 };
 use wasmparser::{Global, Import, Parser, Payload::*, SectionLimited, TypeRef};
 
-use crate::emit::soroban::GET_CONTRACT_DATA;
-use crate::emit::soroban::PUT_CONTRACT_DATA;
+use crate::emit::soroban::{GET_CONTRACT_DATA, PUT_CONTRACT_DATA, LOG_FROM_LINEAR_MEMORY};
 
 pub fn link(input: &[u8], name: &str) -> Vec<u8> {
     let dir = tempdir().expect("failed to create temp directory for linking");
@@ -82,7 +81,7 @@ fn generate_module(input: &[u8]) -> Vec<u8> {
     module.finish()
 }
 
-/// Resolve all pallet contracts runtime imports
+/// Resolve all soroban contracts runtime imports
 fn generate_import_section(section: SectionLimited<Import>, module: &mut Module) {
     let mut imports = ImportSection::new();
     for import in section.into_iter().map(|import| import.unwrap()) {
@@ -98,6 +97,7 @@ fn generate_import_section(section: SectionLimited<Import>, module: &mut Module)
         };
         let module_name = match import.name {
             GET_CONTRACT_DATA | PUT_CONTRACT_DATA => "l",
+            LOG_FROM_LINEAR_MEMORY => "x",
             _ => panic!("got func {:?}", import),
         };
         // parse the import name to all string after the the first dot