Bugfixes

Author: FractalFir

README.md

@@ -55,7 +55,7 @@ The project is still very early in development, but it has made significant prog
 
 ## Milestones
 - [X] Draft version of the `mycorrhiza` interop layer, capable of creating managed objects, and calling methods. 
-- [ ] Compiling the `core` Rust crate - *Substantial chunk of core now compiles,  with 32 methods having trouble compiling. The compilation still gets terminated early due to errors* 
+- [ ] Compiling the `core` Rust crate - *Substantial chunk of core now compiles,  with many  methods still having trouble compiling. The compilation still gets terminated early due to errors* 
 - [ ] Compiling the `alloc` Rust crate 
 - [ ] Compiling the `std` Rust crate 
 - [ ] Stack unwinding 

src/assembly.rs

@@ -152,6 +152,26 @@ impl Assembly {
             }
         }
     }
+    /// This is used *ONLY* to catch uncaught errors.
+    fn checked_add_fn<'tcx>(&mut self,
+        instance: Instance<'tcx>,
+        tcx: TyCtxt<'tcx>,
+        name: &str)-> Result<(), MethodCodegenError>{
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+           self.add_fn(instance, tcx, name)
+        })) {
+            Ok(success) => success,
+            Err(payload) => {
+                if let Some(msg) = payload.downcast_ref::<&str>() {
+                    eprintln!("fn_add panicked with unhandled message: {msg:?}");
+                    return Ok(());
+                } else {
+                    eprintln!("fn_add panicked with no message.");
+                    return Ok(());
+                }
+            }
+        }
+    }
     //fn terminator_to_ops()
     /// Adds a rust MIR function to the assembly.
     pub fn add_fn<'tcx>(
@@ -313,7 +333,7 @@ impl Assembly {
                 //let instance = crate::utilis::monomorphize(&instance,tcx);
                 let symbol_name = crate::utilis::function_name(item.symbol_name(tcx));
 
-                self.add_fn(instance, tcx, &symbol_name)
+                self.checked_add_fn(instance, tcx, &symbol_name)
                     .expect("Could not add function!");
 
                 Ok(())

src/constant.rs

@@ -61,7 +61,40 @@ fn create_const_adt_from_bytes<'ctx>(
             creator_ops.push(CILOp::FreeTMPLocal);
             creator_ops
         }
-        AdtKind::Enum => todo!("Can't load const enum from bytes {bytes:?}!"),
+        AdtKind::Enum => {
+            let variant_size = crate::utilis::enum_tag_size(adt_def.variants().len() as u64);
+            let mut curr_offset = 0;
+            let enum_ty = Type::from_ty(ty, tyctx, &method_instance);
+            let enum_dotnet:DotnetTypeRef = if let Type::DotnetType(ty_ref) = &enum_ty{
+                ty_ref.as_ref().clone()
+            }
+            else{
+                panic!("Invalid enum type {enum_ty:?}");
+            };
+            let mut ops = vec![CILOp::NewTMPLocal(enum_ty.into())];
+            let curr_variant = match variant_size{
+                0=>todo!("Can't yet handle constant enums with 0-sized tags."),
+                1=>{
+                    curr_offset = 1;
+                    let variant = bytes[0] as u32;
+                    ops.extend([CILOp::LoadAddresOfTMPLocal,CILOp::LdcI32(variant as i32),CILOp::STField(FieldDescriptor::boxed(
+                        enum_dotnet.clone(),
+                        Type::U8,
+                        "_tag".into(),
+                    ))]);
+                    variant
+                }
+                _=>todo!("Can't yet support enums with {variant_size} wide tags."),
+            };
+            assert!(curr_variant < adt_def.variants().len() as u32);
+            let active_variant = &adt_def.variants()[curr_variant.into()];
+            for field in &active_variant.fields{
+                todo!("Can't yet create const enum fields.");
+            }
+            ops.push(CILOp::FreeTMPLocal);
+            //todo!("Can't load const enum from bytes {bytes:?}!");
+            ops
+        }
         AdtKind::Union => todo!("Can't load const union from bytes {bytes:?}!"),
     }
 }

src/lib.rs

@@ -58,7 +58,9 @@ const INSERT_MIR_DEBUG_COMMENTS: bool = false;
 const PRINT_LOCAL_TYPES: bool = false;
 const PRINT_TY_CONVERTION: bool = false;
 /// Tells the codegen to optmize the emiited CIL.
-const OPTIMIZE_CIL: bool = (!INSERT_MIR_DEBUG_COMMENTS) && (true);
+const OPTIMIZE_CIL: bool = (!INSERT_MIR_DEBUG_COMMENTS) && (false);
+/// Turns on the struct spliting optimzation.
+const SPLIT_LOCAL_STRUCTS:bool = false;
 
 /// Changes `.locals` into `.locals init`. Causes the runtime to always initialize local variables.
 /// Try turining on in cause of issues. If it fixes them, then their root cause is UB(eg. use of uninitailized memory).

src/opt/mod.rs

@@ -133,7 +133,9 @@ pub fn opt_method(method: &mut Method, asm: &Assembly) {
         remove_zombie_sets(method.ops_mut());
         method.ops_mut().retain(|op| *op != CILOp::Nop);
         try_alias_locals(method.ops_mut());
-        try_split_locals(method, asm);
+        if crate::SPLIT_LOCAL_STRUCTS{
+            try_split_locals(method, asm);
+        }
         remove_unused_locals(method);
         try_inline_all(method, asm);
     }
@@ -637,6 +639,10 @@ fn try_split_locals(method: &mut Method, asm: &Assembly) {
             .1
             .as_dotnet()
             .expect("Can't spilt non-dotnet types!");
+        if dotnet_tpe.name_path().contains("PtrRepr"){
+            eprintln!("WARINING: PtrRepr is bugged and causes issues during optimzation. It will not be optimized. TODO: figure out why the field `const_ptr` can't be found.");
+            continue;
+        }
         let type_def = asm.get_typedef_by_path(dotnet_tpe.name_path());
         let type_def = if let Some(type_def) = type_def {
             type_def
@@ -668,28 +674,37 @@ fn try_split_locals(method: &mut Method, asm: &Assembly) {
                 continue;
             }
             if let CILOp::LDField(field_desc) = op2 {
-                let field_idx = morphic_fields
+                let field_idx = if let Some(field) = morphic_fields
                     .iter()
                     .position(|mfield| mfield.0 == field_desc.name())
-                    .expect("Cound not find field during spliting!");
+                    {field}
+                    else{
+                        panic!("ERROR: field spliting failed because field {field_desc:?} could not be found. This may be caused by an error during codegen");
+                    };
                 method.ops_mut()[index] = CILOp::Nop;
                 method.ops_mut()[index + 1] = CILOp::LDLoc((field_idx + local_map_start) as u32);
                 continue;
             }
             if let CILOp::LDFieldAdress(field_desc) = op2 {
-                let field_idx = morphic_fields
+                let field_idx = if let Some(field) =  morphic_fields
                     .iter()
                     .position(|mfield| mfield.0 == field_desc.name())
-                    .expect("Cound not find field during spliting!");
+                    {field}
+                    else{
+                        panic!("ERROR: field spliting failed because field {field_desc:?} could not be found. This may be caused by an error during codegen");
+                    };
                 method.ops_mut()[index] = CILOp::Nop;
                 method.ops_mut()[index + 1] = CILOp::LDLocA((field_idx + local_map_start) as u32);
                 continue;
             }
             if let CILOp::STField(field_desc) = op3 {
-                let field_idx = morphic_fields
+                let field_idx = if let Some(field) =  morphic_fields
                     .iter()
                     .position(|mfield| mfield.0 == field_desc.name())
-                    .expect("Cound not find field during spliting!");
+                    {field}
+                    else{
+                        panic!("ERROR: field spliting failed because field {field_desc:?} could not be found. This may be caused by an error during codegen");
+                    };
                 method.ops_mut()[index] = CILOp::Nop;
                 method.ops_mut()[index + 2] = CILOp::STLoc((field_idx + local_map_start) as u32);
                 continue;

src/type.rs

@@ -430,6 +430,7 @@ impl Type {
                 Self::FnDef(call)
             }
             TyKind::Array(element, length) => {
+                //let length = crate::utilis::monomorphize(method, length, tyctx)
                 let length = crate::utilis::try_resolve_const_size(length).unwrap();
 
                 let element = Type::from_ty(*element, tyctx, method);

src/type_def.rs

@@ -233,7 +233,7 @@ impl TypeDef {
         )];
         let mut explicit_offsets = vec![0];
         let tag_size = enum_tag_size(adt_def.variants().len() as u64);
-        assert_ne!(tag_size, 0, "ERROR:{name} has a zero sized tag!");
+        //assert_ne!(tag_size, 0, "ERROR:{name} has a zero sized tag!");
         explicit_offsets.extend(adt_def.variants().iter().map(|_| tag_size));
         let mut inner_types = vec![];
         for variant in adt_def.variants() {

src/utilis.rs

@@ -108,6 +108,7 @@ pub fn tag_from_enum_variants(variants: u64) -> crate::r#type::Type {
     let var_size = enum_tag_size(variants);
     println!("variants:{variants}tag_size:{var_size}");
     match var_size {
+        0 => Type::Void,
         1 => Type::U8,
         2 => Type::U16,
         4 => Type::U32,