From 1b8aba0eb19a0feeb0215ffec8952f5bf07df505 Mon Sep 17 00:00:00 2001 From: salaheldinsoliman Date: Sun, 14 Jul 2024 13:28:29 +0200 Subject: [PATCH] print runtime errors working Signed-off-by: salaheldinsoliman --- src/codegen/dispatch/soroban.rs | 20 ++++++++ src/emit/soroban/mod.rs | 19 ++++++++ src/emit/soroban/target.rs | 81 +++++++++++++++++++++++++++++++++ src/linker/soroban_wasm.rs | 6 +-- 4 files changed, 123 insertions(+), 3 deletions(-) diff --git a/src/codegen/dispatch/soroban.rs b/src/codegen/dispatch/soroban.rs index 94959edd3..2d31f122a 100644 --- a/src/codegen/dispatch/soroban.rs +++ b/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; diff --git a/src/emit/soroban/mod.rs b/src/emit/soroban/mod.rs index 51191ea37..a8ff9c699 100644 --- a/src/emit/soroban/mod.rs +++ b/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) { diff --git a/src/emit/soroban/target.rs b/src/emit/soroban/target.rs index cc50591f7..7ee0a5099 100644 --- a/src/emit/soroban/target.rs +++ b/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) { diff --git a/src/linker/soroban_wasm.rs b/src/linker/soroban_wasm.rs index 0a6be8bc6..ce81e0aa8 100644 --- a/src/linker/soroban_wasm.rs +++ b/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 { let dir = tempdir().expect("failed to create temp directory for linking"); @@ -82,7 +81,7 @@ fn generate_module(input: &[u8]) -> Vec { module.finish() } -/// Resolve all pallet contracts runtime imports +/// Resolve all soroban contracts runtime imports fn generate_import_section(section: SectionLimited, 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, 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