Added support for creating function pointers

FractalFir · FractalFir · commit d2d4ca146307 · 2023-12-30T14:50:12.000+01:00
diff --git a/cargo_tests/build_core/Cargo.toml b/cargo_tests/build_core/Cargo.toml
@@ -8,5 +8,5 @@ edition = "2021"
 [dependencies]
 mycorrhiza = {path="../../mycorrhiza"}
 [workspace]
-
+[profile.release.build-override]
 codegen-units = 1
diff --git a/cargo_tests/build_core/src/main.rs b/cargo_tests/build_core/src/main.rs
@@ -5,8 +5,8 @@
 use mycorrhiza::{start,panic_handler};
 panic_handler!{}
 start!{}
-//#[lang = "eh_personality"]
-//fn rust_eh_personality() {}
+#[lang = "eh_personality"]
+fn rust_eh_personality() {}
 fn main() {
     let sb = mycorrhiza::system::text::StringBuilder::empty();
     sb.append_char('H');
diff --git a/src/assembly.rs b/src/assembly.rs
@@ -415,6 +415,10 @@ impl Assembly {
         //FIXME:This is inefficient.
         self.methods().any(|m| m.name() == name)
     }
+    /// Returns true if assembly contains function named `name`
+    pub fn contains_fn(&self, site: &CallSite) -> bool {
+        self.functions.contains_key(site)
+    }
     /// Adds a method to the assebmly.
     pub fn add_method(&mut self, mut method: Method) {
         method.allocate_temporaries();
diff --git a/src/assembly_exporter/ilasm_op.rs b/src/assembly_exporter/ilasm_op.rs
@@ -49,6 +49,35 @@ pub fn op_cli(op: &crate::cil::CILOp) -> Cow<'static, str> {
                 .into()
             }
         }
+        CILOp::LDFtn(call_site)=>{
+             //assert!(sig.inputs.is_empty());
+             let mut inputs_iter = call_site.explicit_inputs().iter();
+             let mut input_string = String::new();
+             if let Some(firts_arg) = inputs_iter.next() {
+                 input_string.push_str(&non_void_type_cil(firts_arg));
+             }
+             for arg in inputs_iter {
+                 input_string.push(',');
+                 input_string.push_str(&non_void_type_cil(arg));
+             }
+             let prefix = if call_site.is_static() {
+                 ""
+             } else {
+                 "instance"
+             };
+             let owner_name = match call_site.class() {
+                 Some(owner) => {
+                     format!("{}::", type_cil(&owner.clone().into()))
+                 }
+                 None => String::new(),
+             };
+             format!(
+                 "ldftn {prefix} {output} {owner_name} {function_name}({input_string})",
+                 function_name = call_site.name(),
+                 output = type_cil(call_site.signature().output())
+             )
+             .into()
+        }
         CILOp::CallVirt(call_site) => {
             if call_site.is_nop() {
                 "".into()
@@ -400,6 +429,18 @@ pub fn non_void_type_cil(tpe: &Type) -> Cow<'static, str> {
 }
 pub fn type_cil(tpe: &Type) -> Cow<'static, str> {
     match tpe {
+        Type::DelegatePtr(sig)=>{
+            let mut inputs_iter = sig.inputs().iter();
+            let mut input_string = String::new();
+            if let Some(firts_arg) = inputs_iter.next() {
+                input_string.push_str(&non_void_type_cil(firts_arg));
+            }
+            for arg in inputs_iter {
+                input_string.push(',');
+                input_string.push_str(&non_void_type_cil(arg));
+            }
+            format!("method {output}*({input_string})",output = type_cil(sig.output())).into()
+        }
         Type::FnDef(name) => format!("valuetype fn_{name}").into(),
         Type::Void => "void".into(),
         Type::I8 => "int8".into(),
diff --git a/src/bin/linker.rs b/src/bin/linker.rs
@@ -96,7 +96,7 @@ fn autopatch(asm: &mut Assembly) {
     let call_sites = asm
         .call_sites()
         .filter(|call| call.is_static() && call.class().is_none())
-        .filter(|call| !asm.contains_fn_named(call.name()));
+        .filter(|call| !asm.contains_fn(call));
     let mut patched = std::collections::HashMap::new();
     for call in call_sites {
         if !patched.contains_key(call) {
diff --git a/src/bin/rustflags.rs b/src/bin/rustflags.rs
@@ -1,27 +1,64 @@
 fn main() {
     let build_env = rustc_codegen_clr::compile_test::cargo_build_env();
-    println!("In order to compile cargo crates with `rustc_codegen_clr`, please set the RUSTFLAGS enviorment variable to:");
+    let print_raw_env = std::env::args().any(|arg| arg == "--print_raw_env");
+    let setup_command = std::env::args().any(|arg| arg == "--setup_command");
+    if print_raw_env{
+        println!("\"{build_env}\"");
+        return;
+    }
+    if setup_command{
+        #[cfg(target_family = "unix")]
+        println!("export RUSTFLAGS=\"{build_env}\"");
+        #[cfg(target_family = "windows")]
+        println!("$Env:RUSTFLAGS = '{build_env}'");
+        return
+    }
+    println!("Welcome to the `rustc_codegen_clr` environment setup helper!");
+    println!("This tool will help you use the codegen to compile Rust projects.");
+    println!("WARNING: Please note, the project is currently in the early stages of development.  Bugs, crashes and miscompilations will occur.");
+    println!("Currently, there is no way to permanently install the codegen. It is enabled on a per-shell-session basis (enabled for your particular command prompt window).");
+    println!("");
+    println!("In order to compile cargo crates with `rustc_codegen_clr`, please set the RUSTFLAGS environment variable to:");
     println!();
-    println!("\"{build_env}\"");
-    println!();
-    println!("On linux, you may use the following commmand to quickly set the required enviroment variables:");
-    println!();
-    println!("export RUSTFLAGS=\"{build_env}\"");
     println!();
-    println!("On windows(powershell), you may use the following commmand to quickly set the required enviroment variables:");
-    println!();
-    println!("$Env:RUSTFLAGS = '{build_env}'");
-    println!();
-    println!("After you are done working with `rustc_codegen_clr` either unset the enviroment variable OR restart your shell(close the command prompt window).");
-    println!("On linux, you may use the following commmand to quickly unset the required enviroment variables:");
+    println!("\"{build_env}\"");
     println!();
-    println!("unset RUSTFLAGS");
     println!();
-    println!("Please note that those varaibles may change when the codegen is updated/rebuilt.");
-    println!("After each time the codegen is rebuilt, please use this tool again to get updated build enviroment variables.");
+    #[cfg(target_family = "unix")]{
+        println!("You may use the following command to quickly set the required environment variables:");
+        println!();
+        println!();
+        println!("export RUSTFLAGS=\"{build_env}\"");
+        println!();
+        println!();
+    }
+    #[cfg(target_family = "windows")]{
+        println!("You may use the following command to quickly set the required environment variables:");
+        println!();
+        println!();
+        println!("$Env:RUSTFLAGS = '{build_env}'");
+        println!();
+        println!();
+    }
+    println!("After you are done working with `rustc_codegen_clr` either unset the environment variable OR restart your shell (close the command prompt window).");
+    #[cfg(target_family = "unix")]{
+        println!("You may use the following command to quickly unset the required environment variables:");
+        println!();
+        println!();
+        println!("unset RUSTFLAGS");
+        println!();
+        println!();
+    }
+    #[cfg(target_family = "windows")]{
+        println!();
+    }
+    println!("Please note that those variables may change when the codegen is updated/rebuilt.");
+    println!("After each time the codegen is rebuilt, please use this tool again to get updated build environment variables.");
     println!();
     println!("If you are using the project, please remember to:");
     println!("1. Update BOTH rustc and the project on a regular basis.");
-    println!("2. Report compiler bugs to the maintainers of `rustc_codegen_clr` not the maintainers of the compiler as a whole.");
-    println!("  In 99.999% of the cases, the bug is wihin this project and not the compiler.");
+    println!("2. Report compiler bugs to the maintainers of `rustc_codegen_clr`, and not the maintainers of the Rust compiler as a whole.");
+    println!("  In 99.999% of the cases, the bug is within this project and not the Rust compiler.");
+    println!("");
+   // std::env::set_var("RUSTFLAGS", build_env);
 }
diff --git a/src/cil/mod.rs b/src/cil/mod.rs
@@ -96,6 +96,8 @@ pub enum CILOp {
     LdcF64(f64),
     /// Load string literal
     LdStr(IString),
+    /// Load the address of a function
+    LDFtn(Box<CallSite>),
     /// Load null reference
     LdNull,
     /// Signed intieger convertions
@@ -252,12 +254,13 @@ impl CILOp {
             _ => (),
         }
     }
-    /// If the cil op is a call, virtual call or new object cosntructor, returns the [`CallSite`] representing the called function.
+    /// If the cil op is a call, virtual call, new object cosntructor OR it loads a pointer to a function, returns the [`CallSite`] representing this function.
     pub fn call(&self) -> Option<&CallSite> {
         match self {
             Self::Call(site) => Some(site),
             Self::CallVirt(site) => Some(site),
             Self::NewObj(site) => Some(site),
+            Self::LDFtn(site)=>Some(site),
             _ => None,
         }
     }
@@ -444,6 +447,7 @@ impl CILOp {
             | CILOp::LoadAdressUnderTMPLocal(_)
             | CILOp::LoadTMPLocal => 1,
             CILOp::SetTMPLocal => -1,
+            CILOp::LDFtn(_) => 1,
             CILOp::LoadGlobalAllocPtr { alloc_id: _ } => 1,
         }
     }
diff --git a/src/compile_test.rs b/src/compile_test.rs
@@ -545,9 +545,10 @@ test_lib! {libc}
 
 test_lib! {references}
 //test_lib! {structs}
-
+test_lib! {empty_string_slice}
 test_lib! {types}
 test_lib! {recursive}
+test_lib! {fn_ptr}
 test_lib! {tuple}
 
 run_test! {arthm,add}
diff --git a/src/constant.rs b/src/constant.rs
@@ -195,7 +195,23 @@ fn create_const_from_slice<'ctx>(
                 )),
                 CILOp::ConvUSize(false),
             ],
-            _ => todo!("Can't yet load const value of type {int:?} with bytes:{bytes:?}"),
+            IntTy::I128=>{
+                let value = u128::from_ne_bytes(bytes[..std::mem::size_of::<i128>()].try_into().expect("Invalid slice!"));
+                let low = (value & u128::from(u64::MAX)) as u64;
+                let high = (value << 64) as u64;
+                let low = i64::from_ne_bytes(low.to_ne_bytes());
+                let high = i64::from_ne_bytes(high.to_ne_bytes());
+                let ctor_sig =
+                    crate::function_sig::FnSig::new(&[Type::U64, Type::U64], &Type::Void);
+                vec![CILOp::LdcI64(high),
+                    CILOp::LdcI64(low),
+                    CILOp::NewObj(CallSite::boxed(
+                        Some(DotnetTypeRef::int_128()),
+                        ".ctor".into(),
+                        ctor_sig,
+                        true,
+                    ))]
+            }
         },
         TyKind::Uint(int) => match int {
             UintTy::U8 => vec![
@@ -224,7 +240,23 @@ fn create_const_from_slice<'ctx>(
                 )),
                 CILOp::ConvUSize(false),
             ],
-            _ => todo!("Can't yet load const value of type {int:?} with bytes:{bytes:?}"),
+            UintTy::U128=>{
+                let value = u128::from_ne_bytes(bytes[..std::mem::size_of::<u128>()].try_into().expect("Invalid slice!"));
+                let low = (value & u128::from(u64::MAX)) as u64;
+                let high = (value << 64) as u64;
+                let low = i64::from_ne_bytes(low.to_ne_bytes());
+                let high = i64::from_ne_bytes(high.to_ne_bytes());
+                let ctor_sig =
+                    crate::function_sig::FnSig::new(&[Type::U64, Type::U64], &Type::Void);
+                vec![CILOp::LdcI64(high),
+                    CILOp::LdcI64(low),
+                    CILOp::NewObj(CallSite::boxed(
+                        Some(DotnetTypeRef::uint_128()),
+                        ".ctor".into(),
+                        ctor_sig,
+                        true,
+                    ))]
+            }
         },
         TyKind::RawPtr(type_and_mut) => match type_and_mut.ty.kind() {
             TyKind::Slice(_) => {
diff --git a/src/rvalue.rs b/src/rvalue.rs
@@ -351,6 +351,30 @@ pub fn handle_rvalue<'tcx>(
             }
             ops
         }
+        Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer), operand,target)=>{
+            let operand_ty = operand.ty(method,tyctx);
+            operand.constant().expect("function must be constant in order to take its adress!");
+            let operand_ty = crate::utilis::monomorphize(&method_instance, operand_ty, tyctx);
+            let target = crate::utilis::monomorphize(&method_instance, *target, tyctx);
+            let (instance, subst_ref) = if let TyKind::FnDef(def_id, subst_ref) = operand_ty.kind() {
+                let subst = crate::utilis::monomorphize(&method_instance, *subst_ref, tyctx);
+                let env = ParamEnv::reveal_all();
+                let Some(instance) =
+                    Instance::resolve(tyctx, env, *def_id, subst).expect("Invalid function def")
+                else {
+                    panic!("ERROR: Could not get function instance. fn type:{operand_ty:?}")
+                };
+        
+                (instance, subst_ref)
+            } else {
+                todo!("Trying to call a type which is not a function definition!");
+            };
+            let function_name = crate::utilis::function_name(tyctx.symbol_name(instance));
+            let function_sig = FnSig::sig_from_instance_(instance,tyctx,tycache).expect("Could not get function signature when trying to get a function pointer!");
+            //FIXME: propely handle `#[track_caller]`
+            let call_site = CallSite::new(None,function_name,function_sig,true);
+            vec![CILOp::LDFtn(call_site.into())]
+        }
         Rvalue::Cast(kind, _operand, _) => todo!("Unhandled cast kind {kind:?}, rvalue:{rvalue:?}"),
         Rvalue::Discriminant(place) => {
             let mut ops =
@@ -430,6 +454,7 @@ pub fn handle_rvalue<'tcx>(
             ops.push(CILOp::FreeTMPLocal);
             ops
         }
+    
         _ => rustc_middle::ty::print::with_no_trimmed_paths! {todo!("Unhandled RValue {rvalue:?}")},
     };
     res
diff --git a/src/type/tycache.rs b/src/type/tycache.rs
@@ -255,16 +255,6 @@ impl TyCache {
             }
             TyKind::Never => Type::Void,
             TyKind::RawPtr(type_and_mut) => {
-                let (metadata, fat_if_not_sized) =
-                    type_and_mut.ty.ptr_metadata_ty(tyctx, |mut ty| {
-                        method.inspect(|method| {
-                            ty = crate::utilis::monomorphize(method, ty, tyctx);
-                        });
-                        ty
-                    });
-                //TODO: fat_if_not_sized is suposed to tell me if a pointer being fat depends on if the type is sized.
-                // I am not sure how this is suposed to work exactly, so it gets ignored for now.
-                let is_sized = type_and_mut.ty.is_sized(tyctx, ParamEnv::reveal_all());
                 if super::pointer_to_is_fat(type_and_mut.ty, tyctx, method) {
                     let inner = match type_and_mut.ty.kind() {
                         TyKind::Slice(inner) => {
@@ -302,16 +292,8 @@ impl TyCache {
                 Type::Unresolved
             }
             TyKind::Ref(_region, inner, _mut) => {
-                let (metadata, fat_if_not_sized) = inner.ptr_metadata_ty(tyctx, |mut ty| {
-                    method.inspect(|method| {
-                        ty = crate::utilis::monomorphize(method, ty, tyctx);
-                    });
-                    ty
-                });
-                //TODO: fat_if_not_sized is suposed to tell me if a pointer being fat depends on if the type is sized.
-                // I am not sure how this is suposed to work exactly, so it gets ignored for now.
-                let is_sized = inner.is_sized(tyctx, ParamEnv::reveal_all());
-                if !is_sized {
+
+                if super::pointer_to_is_fat(*inner, tyctx, method) {
                     let inner = match inner.kind() {
                         TyKind::Slice(inner) => {
                             let inner = if let Some(method) = method {
@@ -352,9 +334,17 @@ impl TyCache {
                 Type::Foreign
             }
             TyKind::Bound(_, _inner) => Type::Foreign,
-            TyKind::FnPtr(_) => Type::USize,
-            TyKind::Slice(_inner) => {
-                todo!("Slice!")
+            TyKind::FnPtr(sig)=> {
+                let sig = if let Some(method) = method {
+                    crate::utilis::monomorphize(&method, *sig, tyctx)
+                } else {
+                    *sig
+                };
+                let sig = sig.skip_binder();
+                let output =  self.type_from_cache(sig.output(), tyctx, method);
+                let inputs:Box<[Type]> =  sig.inputs().iter().map(|input|self.type_from_cache(*input, tyctx, method)).collect();
+                let sig = FnSig::new(&inputs,&output);
+                Type::DelegatePtr(sig.into())
             }
             TyKind::FnDef(did, subst) => {
                 let instance = Instance::resolve(tyctx, ParamEnv::reveal_all(), *did, subst)
diff --git a/src/type/type.rs b/src/type/type.rs
diff --git a/src/utilis.rs b/src/utilis.rs

Original file line number	Diff line number	Diff line change
`@@ -96,6 +96,8 @@ pub enum CILOp {`
`96`	`96`	`LdcF64(f64),`
`97`	`97`	`/// Load string literal`
`98`	`98`	`LdStr(IString),`
	`99`	`+ /// Load the address of a function`
	`100`	`+ LDFtn(Box<CallSite>),`
`99`	`101`	`/// Load null reference`
`100`	`102`	`LdNull,`
`101`	`103`	`/// Signed intieger convertions`
`@@ -252,12 +254,13 @@ impl CILOp {`
`252`	`254`	`_ => (),`
`253`	`255`	`}`
`254`	`256`	`}`
`255`		- /// If the cil op is a call, virtual call or new object cosntructor, returns the [`CallSite`] representing the called function.
	`257`	+ /// If the cil op is a call, virtual call, new object cosntructor OR it loads a pointer to a function, returns the [`CallSite`] representing this function.
`256`	`258`	`pub fn call(&self) -> Option<&CallSite> {`
`257`	`259`	`match self {`
`258`	`260`	`Self::Call(site) => Some(site),`
`259`	`261`	`Self::CallVirt(site) => Some(site),`
`260`	`262`	`Self::NewObj(site) => Some(site),`
	`263`	`+ Self::LDFtn(site)=>Some(site),`
`261`	`264`	`_ => None,`
`262`	`265`	`}`
`263`	`266`	`}`
`@@ -444,6 +447,7 @@ impl CILOp {`
`444`	`447`	`\| CILOp::LoadAdressUnderTMPLocal(_)`
`445`	`448`	`\| CILOp::LoadTMPLocal => 1,`
`446`	`449`	`CILOp::SetTMPLocal => -1,`
	`450`	`+ CILOp::LDFtn(_) => 1,`
`447`	`451`	`CILOp::LoadGlobalAllocPtr { alloc_id: _ } => 1,`
`448`	`452`	`}`
`449`	`453`	`}`