Updated rustc

Author: FractalFir

src/basic_block.rs

@@ -1,5 +1,5 @@
 use cilly::basic_block::Handler;
-use rustc_middle::mir::BasicBlockData;
+use rustc_middle::mir::{BasicBlockData,BasicBlock};
 use rustc_middle::mir::UnwindAction;
 use rustc_middle::{
     mir::{BasicBlocks, Body, TerminatorKind},
@@ -35,10 +35,10 @@ fn simplify_handler<'tcx>(
         return None;
     }
     let handler = handler?;
-    if !blocks[handler.into()].statements.is_empty() {
+    if !blocks[BasicBlock::from_u32(handler)].statements.is_empty() {
         return Some(handler);
     }
-    match blocks[handler.into()].terminator.as_ref()?.kind {
+    match blocks[BasicBlock::from_u32(handler)].terminator.as_ref()?.kind {
         TerminatorKind::TailCall { .. } => None,
         TerminatorKind::Goto { target } => {
             simplify_handler(Some(target.as_u32()), blocks, tcx, method_instance, method)

src/place/body.rs

@@ -10,13 +10,13 @@ use cilly::{
     call,
     cil_node::CILNode,
     conv_usize, ld_field,
-    v2::{cilnode::MethodKind, FieldDesc, Int, MethodRef},
+    v2::{FieldDesc, Int},
     Const, IntoAsmIndex, NodeIdx, Type,
 };
-use rustc_middle::mir::PlaceElem;
+use rustc_middle::mir::{Local,PlaceElem};
 use rustc_middle::ty::{Ty, TyKind};
 pub fn local_body<'tcx>(local: usize, ctx: &mut MethodCompileCtx<'tcx, '_>) -> (NodeIdx, Ty<'tcx>) {
-    let ty = ctx.body().local_decls[local.into()].ty;
+    let ty = ctx.body().local_decls[Local::from_usize(local)].ty;
     let ty = ctx.monomorphize(ty);
     if body_ty_is_by_adress(ty, ctx) {
         (super::adress::local_adress(local, ctx.body(), ctx), ty)

src/terminator/intrinsics/mod.rs

@@ -689,7 +689,7 @@ pub fn handle_intrinsic<'tcx>(
         "truncf32" => float_unop(args, destination, ctx, Float::F32, "Truncate"),
         "truncf64" => float_unop(args, destination, ctx, Float::F64, "Truncate"),
         // `roundf32` should be a differnt intrinsics, but it requires some .NET fuckery to implement(.NET enums are **wierd**)
-        "nearbyintf32" | "rintf32" | "roundevenf32" => {
+        "nearbyintf32" | "rintf32" | "round_ties_even_f32" => {
             let round = MethodRef::new(
                 ClassRef::mathf(ctx),
                 ctx.alloc_string("Round"),
@@ -705,7 +705,7 @@ pub fn handle_intrinsic<'tcx>(
         }
         "roundf32" => vec![roundf32(args, destination, ctx)],
         "roundf64" => vec![roundf64(args, destination, ctx)],
-        "nearbyintf64" | "rintf64" | "roundevenf64" => {
+        "nearbyintf64" | "rintf64" | "round_ties_even_f64" => {
             let round = MethodRef::new(
                 ClassRef::math(ctx),
                 ctx.alloc_string("Round"),

src/unsize.rs

@@ -13,6 +13,7 @@ use rustc_middle::{
     mir::{Operand, Place},
     ty::{layout::TyAndLayout, ExistentialTraitRef, Ty, TyKind, UintTy},
 };
+use rustc_abi::FieldIdx;
 
 /// Preforms an unsizing cast on operand `operand`, converting it to the `target` type.
 pub fn unsize2<'tcx>(
@@ -228,8 +229,8 @@ fn unsize_metadata<'tcx>(
             assert_eq!(def_a, def_b);
 
             for i in 0..def_a.variant(FIRST_VARIANT).fields.len() {
-                let src_f = &def_a.variant(FIRST_VARIANT).fields[i.into()];
-                let dst_f = &def_b.variant(FIRST_VARIANT).fields[i.into()];
+                let src_f = &def_a.variant(FIRST_VARIANT).fields[FieldIdx::from_usize(i)];
+                let dst_f = &def_b.variant(FIRST_VARIANT).fields[FieldIdx::from_usize(i)];
                 let src_f_ty = fx.layout_of(src_f.ty(fx.tcx(), subst_a));
                 let dst_f_ty = fx.layout_of(dst_f.ty(fx.tcx(), subst_b));
                 if src_f_ty.layout.is_zst() {

src/utilis/mod.rs

@@ -4,6 +4,7 @@ use cilly::{
     v2::{FieldDesc, FieldIdx},
 };
 use rustc_hir::def_id::DefId;
+use rustc_abi::VariantIdx;
 use rustc_middle::{
     mir::interpret::AllocId,
     ty::{
@@ -81,7 +82,7 @@ pub fn field_name(ty: Ty, idx: u32) -> crate::IString {
 pub fn variant_name(ty: Ty, idx: u32) -> crate::IString {
     match ty.kind() {
         TyKind::Adt(adt_def, _subst) => {
-            let variant_def = &adt_def.variants()[idx.into()];
+            let variant_def = &adt_def.variants()[VariantIdx::from_u32(idx)];
             variant_def.name.to_string().into()
         }
         _ => todo!("Can't yet get fields of typr {ty:?}"),

test/arthm/ptr.rs

@@ -1,8 +1,7 @@
-#![feature(ptr_sub_ptr)]
 use core::ptr::NonNull; 
 fn main(){
 	let mut arr:[u8;10] = [0_u8;10];
 	let offset = NonNull::new(&mut arr[9] as *mut _).unwrap();
 	let start = NonNull::new(&mut arr[0] as *mut _).unwrap();	
-	unsafe{assert_eq!(offset.sub_ptr(start),9)};
+	unsafe{assert_eq!(offset.offset_from_unsigned(start),9)};
 }

test/intrinsics/round.rs

@@ -15,12 +15,10 @@ use core::intrinsics::fabsf32;
 use core::intrinsics::fabsf64;
 use core::intrinsics::floorf32;
 use core::intrinsics::floorf64;
-use core::intrinsics::nearbyintf32;
-use core::intrinsics::nearbyintf64;
 use core::intrinsics::rintf32;
 use core::intrinsics::rintf64;
-use core::intrinsics::roundevenf32;
-use core::intrinsics::roundevenf64;
+use core::intrinsics::round_ties_even_f32;
+use core::intrinsics::round_ties_even_f64;
 use core::intrinsics::roundf32;
 use core::intrinsics::roundf64;
 use core::intrinsics::truncf32;
@@ -37,10 +35,6 @@ fn main() {
     test_eq!(unsafe { fabsf64(x) }, black_box(x));
     test_eq!(unsafe { fabsf64(y) }, black_box(-y));
     test!(unsafe { fabsf64(f64::NAN) }.is_nan());
-    test_eq!(unsafe { nearbyintf32(2.5f32) }, black_box(2.0));
-    test_eq!(unsafe { nearbyintf32(3.5f32) }, black_box(4.0));
-    test_eq!(unsafe { nearbyintf64(2.5f64) }, black_box(2.0));
-    test_eq!(unsafe { nearbyintf64(3.5f64) }, black_box(4.0));
     let f = 3.3_f32;
     let g = -3.3_f32;
     let h = 3.5_f32;
@@ -61,18 +55,18 @@ fn main() {
     let g = -3.3_f32;
     let h = 3.5_f32;
     let i = 4.5_f32;
-    test_eq!(unsafe { roundevenf32(f) }, black_box(3.0));
-    test_eq!(unsafe { roundevenf32(g) }, black_box(-3.0));
-    test_eq!(unsafe { roundevenf32(h) }, black_box(4.0));
-    test_eq!(unsafe { roundevenf32(i) }, black_box(4.0));
+    test_eq!(unsafe { round_ties_even_f32(f) }, black_box(3.0));
+    test_eq!(unsafe { round_ties_even_f32(g) }, black_box(-3.0));
+    test_eq!(unsafe { round_ties_even_f32(h) }, black_box(4.0));
+    test_eq!(unsafe { round_ties_even_f32(i) }, black_box(4.0));
     let f = 3.3_f64;
     let g = -3.3_f64;
     let h = 3.5_f64;
     let i = 4.5_f64;
-    test_eq!(unsafe { roundevenf64(f) }, black_box(3.0));
-    test_eq!(unsafe { roundevenf64(g) }, black_box(-3.0));
-    test_eq!(unsafe { roundevenf64(h) }, black_box(4.0));
-    test_eq!(unsafe { roundevenf64(i) }, black_box(4.0));
+    test_eq!(unsafe { round_ties_even_f64(f) }, black_box(3.0));
+    test_eq!(unsafe { round_ties_even_f64(g) }, black_box(-3.0));
+    test_eq!(unsafe { round_ties_even_f64(h) }, black_box(4.0));
+    test_eq!(unsafe { round_ties_even_f64(i) }, black_box(4.0));
     let f = 3.3_f32;
     let g = -3.3_f32;
     let h = -3.7_f32;