Some work on fixing unsizinv

Author: FractalFir

Cargo.toml

@@ -20,6 +20,7 @@ rustc-demangle = "0.1.23"
 cilly = {path = "./cilly"}
 serde = { version = "1.0.183", features = ["derive"] }
 strsim = "0.11.1"
+
 [lib]
 crate-type=["rlib", "cdylib"]
 

cargo_tests/build_std/src/main.rs

@@ -5,3 +5,6 @@ fn should_pass() {}
 fn should_panic() {
     panic!();
 }
+fn main() {
+    println!("Hi!");
+}

cilly/src/asm.rs

@@ -179,7 +179,7 @@ edge [fontname=\"Helvetica,Arial,sans-serif\"]\nnode [shape=box];\n".to_string()
             .find(|&tpe| tpe.0.as_ref() == path)
             .map(|t| t.1)
     }
-    pub fn finalize(&mut self) {
+    pub fn resolve_method_aliases(&mut self) {
         for method in self
             .types
             .iter_mut()
@@ -192,7 +192,8 @@ edge [fontname=\"Helvetica,Arial,sans-serif\"]\nnode [shape=box];\n".to_string()
                 .next()
             {
                 let Some(target) = self.functions.get(site) else {
-                    panic!("can't find  {site:?}");
+                    eprintln!("can't find  {site:?}");
+                    eprintln!("can't find  {site:?}");
                     continue;
                 };
                 method.set_locals(target.locals());

cilly/src/bin/linker/main.rs

@@ -730,6 +730,7 @@ fn main() {
 
     let (mut final_assembly, linkables) =
         load::load_assemblies(to_link.as_slice(), ar_to_link.as_slice());
+    final_assembly.resolve_method_aliases();
     // Aplly certain fixes/workarounds to the final assembly
     override_errno(&mut final_assembly);
     patch::patch_all(&mut final_assembly);
@@ -751,9 +752,9 @@ fn main() {
         || output_file_path.contains(".so")
         || output_file_path.contains(".o");
     add_mandatory_statics(&mut final_assembly);
-    final_assembly.finalize();
+
     if !is_lib {
-        final_assembly.eliminate_dead_code();
+        //final_assembly.eliminate_dead_code();
     }
     if *C_MODE {
         type Exporter = cilly::c_exporter::CExporter;

setup_rustc_fork.sh

@@ -22,7 +22,7 @@ cat > config.toml <<EOF
 change-id = 999999
 
 [build]
-rustc = "rustc"
+rustc = "$(rustup which rustc)"
 cargo = "$(rustup which cargo)"
 full-bootstrap = false
 local-rebuild = true

src/assembly.rs

@@ -306,6 +306,9 @@ pub fn add_fn<'tcx>(
     }
     let mir = tcx.instance_mir(instance.def);
     if name.contains("rustc_codegen_clr_comptime_entrypoint") {
+        if name.contains("rustc_codegen_clr_not_magic") {
+            return Ok(());
+        }
         crate::comptime::interpret(asm, instance, tcx, mir, cache);
         return Ok(());
     }
@@ -884,6 +887,7 @@ impl<'tcx, 'validator, 'type_cache> MethodCompileCtx<'tcx, 'validator, 'type_cac
         &self,
         ty: rustc_middle::ty::Ty<'tcx>,
     ) -> rustc_middle::ty::layout::TyAndLayout<'tcx> {
+        let ty = self.monomorphize(ty);
         self.tcx
             .layout_of(rustc_middle::ty::ParamEnvAnd {
                 param_env: ParamEnv::reveal_all(),
@@ -892,3 +896,18 @@ impl<'tcx, 'validator, 'type_cache> MethodCompileCtx<'tcx, 'validator, 'type_cac
             .expect("Could not get type layout!")
     }
 }
+impl<'tcx> rustc_middle::ty::layout::HasTyCtxt<'tcx> for MethodCompileCtx<'tcx, '_, '_> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+}
+impl rustc_abi::HasDataLayout for MethodCompileCtx<'_, '_, '_> {
+    fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
+        self.tcx.data_layout()
+    }
+}
+impl<'tcx> rustc_middle::ty::layout::HasParamEnv<'tcx> for MethodCompileCtx<'tcx, '_, '_> {
+    fn param_env(&self) -> ParamEnv<'tcx> {
+        ParamEnv::reveal_all()
+    }
+}

src/comptime.rs

@@ -40,7 +40,18 @@ pub fn interpret<'tcx>(
             match &statement.kind {
                 StatementKind::Assign(bx) => {
                     let (target, rvalue) = bx.as_ref();
-                    let Rvalue::Use(src) = rvalue else { panic!() };
+                    let src = match rvalue {
+                        Rvalue::Use(src) => src,
+                        Rvalue::Cast(
+                            rustc_middle::mir::CastKind::PointerCoercion(
+                                rustc_middle::ty::adjustment::PointerCoercion::ReifyFnPointer,
+                            ),
+                            _,
+                            _,
+                        ) => continue,
+                        _ => panic!(),
+                    };
+
                     let src = src.place().unwrap().as_local().unwrap();
                     let target = target.as_local().unwrap();
                     locals[usize::from(target)] = locals[usize::from(src)].clone();
@@ -130,6 +141,8 @@ pub fn interpret<'tcx>(
                             .expect("ERROR: unuported operation in interop type definiton.");
                         asm.add_typedef(locals[usize::from(local)].as_type_def().unwrap().clone());
                         ComptimeLocalVar::Void
+                    } else if function_name == "black_box".into() {
+                        ComptimeLocalVar::NotSet
                     } else if function_name.contains("rustc_codegen_clr_add_field_def") {
                         let src = args[0]
                             .node

src/config.rs

@@ -39,6 +39,9 @@ config_flag! {INSERT_MIR_DEBUG_COMMENTS,false,"Tells the codegen to insert comme
 config_flag! {PRINT_LOCAL_TYPES,false,"Prints local types of all compiled MIR functions."}
 config_flag! {VALIDTE_VALUES,false,"Tells the codegen to insert additional checks on each variable asigement."}
 config_flag! {OPTIMIZE_CIL,true,"Tells the codegen to optmize the emiited CIL."}
+
+config_flag! {NEW_UNSIZE,false,"Turns out the new unsizing code"}
+
 lazy_static! {
     #[doc = "Tells the codegen to escape class and method names."]pub static ref ESCAPE_NAMES:bool = {
         std::env::vars().find_map(|(key,value)|if key == stringify!(ESCAPE_NAMES){

src/rvalue.rs

@@ -1,7 +1,9 @@
 use crate::{
     assembly::MethodCompileCtx,
-    operand::handle_operand,
+    operand::{handle_operand, operand_address},
+    place::{place_address_raw, place_get},
     r#type::{pointer_to_is_fat, Type},
+    unsize::coerce_unsized_into,
 };
 use cilly::{
     call_site::CallSite, cil_node::CILNode, cil_root::CILRoot, conv_usize,
@@ -45,7 +47,31 @@ pub fn handle_rvalue<'tcx>(
             dst,
         ) => ptr_to_ptr(ctx, operand, *dst),
         Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize), operand, target) => {
-            crate::unsize::unsize(ctx, operand, *target)
+            if *crate::config::NEW_UNSIZE {
+                let src_cil = handle_operand(operand, ctx);
+                let src_cil = match src_cil.validate(ctx.validator(), None).unwrap() {
+                    Type::Ptr(_) => src_cil,
+                    Type::DotnetType(_) => operand_address(operand, ctx),
+                    _ => todo!(),
+                };
+                let src_type = src_cil.validate(ctx.validator(), None).unwrap();
+                assert!(matches!(src_type, Type::Ptr(_)), "{src_type:?}");
+                let dst_ty = ctx.layout_of(target_location.ty(ctx.body(), ctx.tcx()).ty);
+                let dst_cil = place_address_raw(target_location, ctx);
+                let coerce = coerce_unsized_into(
+                    ctx,
+                    src_cil,
+                    ctx.layout_of(operand.ty(ctx.body(), ctx.tcx())),
+                    dst_ty,
+                    dst_cil,
+                );
+                CILNode::SubTrees(Box::new((
+                    coerce.into(),
+                    Box::new(place_get(target_location, ctx)),
+                )))
+            } else {
+                crate::unsize::unsize(ctx, operand, *target)
+            }
         }
         Rvalue::BinaryOp(binop, operands) => {
             crate::binop::binop(*binop, &operands.0, &operands.1, ctx)