Updated rustc version

Author: FractalFir

cilly/src/bin/linker/main.rs

@@ -328,9 +328,9 @@ fn main() {
     }
     if !*PANIC_MANAGED_BT {
         if *C_MODE {
-            cilly::v2::builtins::unwind::c_raise_exception(&mut final_assembly, &mut overrides);
+           //cilly::v2::builtins::unwind::c_raise_exception(&mut final_assembly, &mut overrides);
         } else {
-            cilly::v2::builtins::unwind::raise_exception(&mut final_assembly, &mut overrides);
+            //cilly::v2::builtins::unwind::raise_exception(&mut final_assembly, &mut overrides);
         }
     }
     if !*C_MODE {

cilly/src/v2/builtins/unwind.rs

@@ -208,16 +208,7 @@ pub fn place_elem_body<'tcx>(
             parrent_node,
             *index,
         ),
-        PlaceElem::Subtype(tpe) => {
-            if body_ty_is_by_address(curr_type.as_ty().unwrap(), ctx) {
-                (
-                    PlaceTy::Ty(*tpe),
-                    super::deref_op((*tpe).into(), ctx, parrent_node),
-                )
-            } else {
-                (PlaceTy::Ty(*tpe), parrent_node)
-            }
-        }
+      
         PlaceElem::ConstantIndex {
             offset,
             min_length: _,

rustc_codegen_clr_place/src/body.rs

@@ -231,13 +231,7 @@ fn place_elem_get<'a>(
                 }
             }
         }
-        PlaceElem::Subtype(tpe) => {
-            if body_ty_is_by_address(curr_type.as_ty().unwrap(), ctx) {
-                super::deref_op((*tpe).into(), ctx, addr_calc)
-            } else {
-                addr_calc
-            }
-        }
+       
         _ => todo!("Can't handle porojection {place_elem:?} in get"),
     }
 }

rustc_codegen_clr_place/src/get.rs

@@ -213,8 +213,10 @@ pub fn field_descrptor<'tcx>(
             field_type,
         ));
     } else if let TyKind::Coroutine(_, args) = owner_ty.kind() {
-        let coroutine = args.as_coroutine().witness();
-        let TyKind::CoroutineWitness(_, fields) = coroutine.kind() else {
+        todo!();
+        /*
+        let coroutine = args.as_coroutine();
+        let TyKind::CoroutineWitness(_, fields) = coroutine.kind_ty() else {
             panic!("corutine witness is not CoroutineWitness.");
         };
         let field_type = fields
@@ -234,7 +236,7 @@ pub fn field_descrptor<'tcx>(
             owner_type.as_class_ref().expect("Coroutine type invalid!"),
             field_name,
             field_type,
-        ));
+        )); */
     }
     let (adt, subst) = as_adt(owner_ty).expect("Tried to get a field of a non ADT or tuple type!");
     let field = adt

rustc_codegen_clr_type/src/adt.rs

@@ -129,7 +129,7 @@ pub fn get_type<'tcx>(ty: Ty<'tcx>, ctx: &mut MethodCompileCtx<'tcx, '_>) -> Typ
             }
             Type::ClassRef(cref)
         }
-        TyKind::Dynamic(_list, _, _) => {
+        TyKind::Dynamic(_list, _) => {
             let name = ctx.alloc_string("Dyn");
             let cref = ctx.alloc_class_ref(ClassRef::new(name, None, true, [].into()));
             if ctx.class_ref_to_def(cref).is_none() {

rustc_codegen_clr_type/src/type.rs

@@ -120,7 +120,7 @@ fn const_slice_backer_type<'tcx>(
     Type::ClassRef(arr_tpe)
 }
 pub fn load_const_value<'tcx>(
-    const_val: ConstValue<'tcx>,
+    const_val: ConstValue,
     const_ty: Ty<'tcx>,
     ctx: &mut MethodCompileCtx<'tcx, '_>,
 ) -> V1Node {
@@ -135,11 +135,13 @@ pub fn load_const_value<'tcx>(
             let tpe = ctx.type_from_cache(tpe);
             V1Node::uninit_val(tpe, ctx)
         }
-        ConstValue::Slice { data, meta } => {
+        ConstValue::Slice {  meta,alloc_id } => {
+              // SUS
+                      let data = ctx.tcx().global_alloc(alloc_id).unwrap_memory();
             let slice_type = ctx.type_from_cache(const_ty);
             let slice_dotnet = slice_type.as_class_ref().expect("Slice type invalid!");
 
-            let alloc_id = ctx.tcx().reserve_and_set_memory_alloc(data);
+            let alloc_id = alloc_id;
 
             let ptr = if meta == 0 {
                 ctx.alloc_node(Const::USize(1 << 30))
@@ -173,7 +175,7 @@ fn load_scalar_ptr(
     ptr: rustc_middle::mir::interpret::Pointer,
     tpe: Interned<Type>,
 ) -> Interned<CILNode> {
-    let (alloc_id, offset) = ptr.into_parts();
+    let (alloc_id, offset) = ptr. into_raw_parts();
     let global_alloc = ctx.tcx().global_alloc(alloc_id.alloc_id());
     let u8_ptr = ctx.nptr(Type::Int(Int::U8));
     let u8_ptr_ptr = ctx.nptr(u8_ptr);
@@ -255,6 +257,7 @@ fn load_scalar_ptr(
             );
             CILNode::LdFtn(ctx.alloc_methodref(mref)).into_idx(ctx)
         }
+        GlobalAlloc::TypeId{..} => todo!(),
         GlobalAlloc::VTable(_, _) => {
             let (ty, polyref) = global_alloc.unwrap_vtable();
             get_vtable(

rustc_codgen_clr_operand/src/constant.rs

@@ -64,7 +64,9 @@ pub fn is_uninit<'tcx>(operand: &Operand<'tcx>, ctx: &mut MethodCompileCtx<'tcx,
                     // ZeroSized has no data, so I guess it has no initialized data, so assiments using it could propably be safely skipped.
                     true
                 }
-                ConstValue::Slice { data, .. } => {
+                ConstValue::Slice { alloc_id,meta } => {
+                    // SUS
+                      let data = ctx.tcx().global_alloc(alloc_id).unwrap_memory();
                     let mask = data.inner().init_mask();
                     let mut chunks =
                         mask.range_as_init_chunks(rustc_const_eval::interpret::AllocRange {

rustc_codgen_clr_operand/src/lib.rs

@@ -1,3 +1,5 @@
+
+
 use crate::constant::static_ty;
 use cilly::{
     Access, Const, FnSig, Int, Interned, IntoAsmIndex, MethodDef, MethodDefIdx, MethodRef,
@@ -75,6 +77,7 @@ fn alloc_default_type(alloc_id: u64, ctx: &mut MethodCompileCtx<'_, '_>) -> Type
         GlobalAlloc::Function { .. } => {
             todo!()
         }
+        GlobalAlloc::TypeId{..}=>todo!(),
     };
     let tpe = match alloc.0.0.align.bytes() {
         ..1 => Int::U8,
@@ -141,6 +144,7 @@ pub fn add_allocation(
             return (ctx.load_static(field_desc));
             //todo!("Function/Vtable allocation.");
         }
+        GlobalAlloc::TypeId{..} => todo!(),
     };
 
     let const_allocation = const_allocation.inner();

rustc_codgen_clr_operand/src/static_data.rs

@@ -22,7 +22,7 @@ use rustc_codegen_clr_ctx::function_name;
 pub use rustc_codegen_clr_ctx::MethodCompileCtx;
 use rustc_codegen_clr_type::{adt::field_descrptor, r#type::get_type, utilis::is_zst, GetTypeExt};
 use rustc_codgen_clr_operand::static_data::add_static;
-use rustc_middle::mir::mono::Linkage;
+use rustc_hir::attrs::Linkage;
 use rustc_middle::{
     mir::{interpret::GlobalAlloc, mono::MonoItem, Local, LocalDecl, Statement, Terminator},
     ty::{TyCtxt, TyKind},