More layout checks, fixes to some tests

FractalFir · FractalFir · commit cc93c033eacc · 2025-04-29T21:18:53.000+02:00
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -37,4 +37,14 @@ jobs:
         run: ilasm --version
       - name: Run cargo tests
         run: cargo test --verbose ::stable -- --skip f128 --skip num_test
+  linux_c_test:
+    runs-on: ubuntu-22.04
+    env: 
+    	C_MODE: 1
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build
+        run: cargo build
+      - name: Run cargo tests
+        run: cargo test --verbose ::stable -- --skip f128 --skip num_test --skip arithmetic_misc --skip simd --skip round --skip interop
  
diff --git a/QUICKSTART.md b/QUICKSTART.md
@@ -101,4 +101,4 @@ By default, `cg_clr` will keep symbol(function) names more-or-less intact. Howev
 ```
 _ZN54_$LT$$LP$A$C$B$RP$$u20$as$u20$fuzz100__PrintFDebug$GT$12printf_debug17h769fc7ecbdc54ca9E
 ```
-In those cases, simply set `ASCI_IDENT` enviroment variable to ensure correct symbol names.
+In those cases, simply set `ASCI_IDENT` enviroment variable to ensure correct symbol names
diff --git a/cilly/src/bin/linker/main.rs b/cilly/src/bin/linker/main.rs
@@ -504,18 +504,20 @@ fn main() {
     let _ = final_assembly.tcctor();
     let _ = final_assembly.cctor();
     let float128 = final_assembly.alloc_string("f128");
-    final_assembly.class_def(ClassDef::new(
-        float128,
-        true,
-        0,
-        None,
-        vec![],
-        vec![],
-        cilly::Access::Public,
-        NonZeroU32::new(16),
-        NonZeroU32::new(16),
-        true,
-    ));
+    final_assembly
+        .class_def(ClassDef::new(
+            float128,
+            true,
+            0,
+            None,
+            vec![],
+            vec![],
+            cilly::Access::Public,
+            NonZeroU32::new(16),
+            NonZeroU32::new(16),
+            true,
+        ))
+        .unwrap();
 
     final_assembly.patch_missing_methods(&externs, &modifies_errno, &overrides);
     final_assembly.patch_missing_methods(&externs, &modifies_errno, &overrides);
diff --git a/cilly/src/v2/asm.rs b/cilly/src/v2/asm.rs
@@ -1,7 +1,7 @@
 use super::{
     bimap::{BiMap, BiMapIndex, Interned, IntoBiMapIndex},
     cilnode::{BinOp, ExtendKind, MethodKind, PtrCastRes, UnOp},
-    class::{ClassDefIdx, StaticFieldDef},
+    class::{ClassDefIdx, LayoutError, StaticFieldDef},
     opt::{OptFuel, SideEffectInfoCache},
     Access, CILNode, CILRoot, ClassDef, ClassRef, Const, Exporter, FieldDesc, FnSig, Int,
     IntoAsmIndex, MethodDef, MethodDefIdx, MethodRef, StaticFieldDesc, Type,
@@ -480,19 +480,20 @@ impl Assembly {
         idx
     }
     /// Adds a new class definition to this type
-    pub fn class_def(&mut self, def: ClassDef) -> ClassDefIdx {
+    pub fn class_def(&mut self, def: ClassDef) -> Result<ClassDefIdx, LayoutError> {
+        def.layout_check(self)?;
         let cref = def.ref_to();
         let cref = self.alloc_class_ref(cref);
 
         if self.class_defs.contains_key(&ClassDefIdx(cref)) {
             if self[def.name()].contains("core.ffi.c_void") || self[def.name()].contains("RustVoid")
             {
-                return ClassDefIdx(cref);
+                return Ok(ClassDefIdx(cref));
             }
             panic!()
         }
         self.class_defs.insert(ClassDefIdx(cref), def.clone());
-        ClassDefIdx(cref)
+        Ok(ClassDefIdx(cref))
     }
     pub fn main_module(&mut self) -> ClassDefIdx {
         let main_module = self.alloc_string(MAIN_MODULE);
@@ -515,7 +516,7 @@ impl Assembly {
         if self.class_defs.contains_key(&ClassDefIdx(cref)) {
             ClassDefIdx(cref)
         } else {
-            self.class_def(class_def)
+            self.class_def(class_def).unwrap()
         }
     }
     /// Adds a method definition to this assembly.
@@ -794,6 +795,7 @@ impl Assembly {
             None,
             true,
         ))
+        .unwrap()
     }
     /// Converts the old assembly repr to the new one.
     #[must_use]
diff --git a/cilly/src/v2/builtins/mod.rs b/cilly/src/v2/builtins/mod.rs
@@ -437,18 +437,20 @@ pub fn insert_exception(asm: &mut Assembly, patcher: &mut MissingMethodPatcher)
     let data_pointer = asm.alloc_string("data_pointer");
     let this = asm.alloc_string("this");
     let extends = Some(ClassRef::exception(asm));
-    let rust_exception = asm.class_def(ClassDef::new(
-        rust_exception,
-        false,
-        0,
-        extends,
-        vec![(Type::Int(Int::USize), data_pointer, None)],
-        vec![],
-        Access::Public,
-        None,
-        None,
-        true,
-    ));
+    let rust_exception = asm
+        .class_def(ClassDef::new(
+            rust_exception,
+            false,
+            0,
+            extends,
+            vec![(Type::Int(Int::USize), data_pointer, None)],
+            vec![],
+            Access::Public,
+            None,
+            None,
+            true,
+        ))
+        .unwrap();
     let ctor = asm.alloc_string(".ctor");
     let sig = asm.sig(
         [Type::ClassRef(*rust_exception), Type::Int(Int::USize)],
diff --git a/cilly/src/v2/builtins/thread.rs b/cilly/src/v2/builtins/thread.rs
@@ -412,19 +412,21 @@ pub fn instert_threading(asm: &mut Assembly, patcher: &mut MissingMethodPatcher)
     let start_fn_tpe = Type::FnPtr(start_fn_sig);
     let start_fn = asm.alloc_string("start_fn");
     let data = asm.alloc_string("data");
-    let unmanaged_start = asm.class_def(ClassDef::new(
-        uts,
-        false,
-        0,
-        Some(object),
-        vec![(start_fn_tpe, start_fn, None), (void_ptr, data, None)],
-        vec![],
-        // TODO: fix the bug which causes this to be cleaned up by dead code elimination when access is set to Public.
-        Access::Extern,
-        None,
-        None,
-        true,
-    ));
+    let unmanaged_start = asm
+        .class_def(ClassDef::new(
+            uts,
+            false,
+            0,
+            Some(object),
+            vec![(start_fn_tpe, start_fn, None), (void_ptr, data, None)],
+            vec![],
+            // TODO: fix the bug which causes this to be cleaned up by dead code elimination when access is set to Public.
+            Access::Extern,
+            None,
+            None,
+            true,
+        ))
+        .unwrap();
 
     let ctor = asm.alloc_string(".ctor");
     let this = asm.alloc_node(CILNode::LdArg(0));
diff --git a/cilly/src/v2/class.rs b/cilly/src/v2/class.rs
@@ -6,6 +6,14 @@ use crate::Access;
 use crate::{utilis::assert_unique, IString};
 use serde::{Deserialize, Serialize};
 use std::{num::NonZeroU32, ops::Deref};
+#[derive(Debug)]
+pub enum LayoutError {
+    ManagedRefInOverlapingField {
+        owner: String,
+        field: String,
+        name: String,
+    },
+}
 #[derive(Hash, PartialEq, Eq, Copy, Clone, Debug, Serialize, Deserialize)]
 pub struct ClassDefIdx(pub Interned<ClassRef>);
 impl ClassDefIdx {
@@ -515,6 +523,20 @@ impl ClassDef {
         assert_eq!(self.generics, 0);
         ClassRef::new(self.name, None, self.is_valuetype, vec![].into())
     }
+    pub fn layout_check(&self, asm: &Assembly) -> Result<(), LayoutError> {
+        if !self.has_nonveralpping_layout() {
+            for (t, name, _offset) in self.fields() {
+                if t.is_gcref(asm) {
+                    return Err(LayoutError::ManagedRefInOverlapingField {
+                        owner: asm[self.name()].into(),
+                        field: t.mangle(asm),
+                        name: asm[*name].into(),
+                    });
+                }
+            }
+        }
+        Ok(())
+    }
     pub fn add_def(&mut self, val: MethodDefIdx) {
         self.methods.push(val);
         assert_unique(self.methods(), "add_def failed: method were not unique!");
diff --git a/cilly/src/v2/opt/mod.rs b/cilly/src/v2/opt/mod.rs
@@ -4,7 +4,10 @@ use root::root_opt;
 use super::Float;
 
 use super::{
-    bimap::Interned, cilroot::BranchCond, method::LocalDef, typecheck::display_typecheck_err,
+    bimap::Interned,
+    cilroot::BranchCond,
+    method::LocalDef,
+    typecheck::{display_typecheck_err, TypeCheckError},
     BasicBlock, CILIter, CILIterElem, CILNode, CILRoot, FieldDesc, FnSig, Int, MethodImpl, Type,
 };
 use crate::{Assembly, MethodDef};
@@ -650,19 +653,19 @@ impl MethodDef {
             });
         }
     }
-    pub fn typecheck(&mut self, asm: &mut Assembly) {
+    pub fn typecheck(&mut self, asm: &mut Assembly) -> Result<(), TypeCheckError> {
         let sig = self.sig();
         let locals = self.iter_locals(asm).cloned().collect::<Vec<_>>();
-        let name = self.name();
         if let Some(roots) = self.iter_roots_mut() {
-            roots.for_each(|root| {
+            for root in roots {
                 let check = asm.get_root(*root).clone().typecheck(sig, &locals, asm);
                 if check.is_err() {
                     display_typecheck_err(*root, asm, sig, &locals);
                 };
-                check.unwrap_or_else(|_| eprintln!("Could not verify method {}", &asm[name]))
-            })
+                check?
+            }
         }
+        Ok(())
     }
     pub fn optimize(
         &mut self,
diff --git a/cilly/src/v2/tpe/mod.rs b/cilly/src/v2/tpe/mod.rs
@@ -39,6 +39,24 @@ pub enum GenericKind {
     TypeGeneric,
 }
 impl Type {
+    /// Checks if this type is a GC reference. This function may raise false positive.
+    pub fn is_gcref(&self, asm: &Assembly) -> bool {
+        match self {
+            Type::ClassRef(c) => !asm[*c].is_valuetype(),
+            // Conservatively assume all C# generic. *could* be GC refs.
+            Type::PlatformGeneric(_, _) => true,
+            Type::PlatformArray { .. } | Type::PlatformObject | Type::PlatformString => true,
+            Type::Int(_)
+            | Type::Float(_)
+            | Type::Bool
+            | Type::PlatformChar
+            | Type::Void
+            | Type::Ptr(_)
+            | Type::Ref(_)
+            | Type::FnPtr(_)
+            | Type::SIMDVector(_) => false,
+        }
+    }
     pub fn iter_class_refs<'a, 'asm: 'a>(
         &'a self,
         asm: &'asm Assembly,
diff --git a/cilly/src/v2/typecheck.rs b/cilly/src/v2/typecheck.rs
@@ -197,6 +197,10 @@ pub enum TypeCheckError {
         /// The kind of operation that was done.
         op: BinOp,
     },
+    ManagedPtrCast {
+        src: String,
+        dst: String,
+    },
 }
 /// Converts a typecheck error to a graph representing the issue with the typecheck process.
 pub fn typecheck_err_to_string(
@@ -772,15 +776,27 @@ impl CILNode {
                 let arg = asm.get_node(*arg).clone();
                 let arg_tpe = arg.typecheck(sig, locals, asm)?;
                 match arg_tpe {
-                    Type::Ptr(_)
-                    | Type::Ref(_)
-                    | Type::Int(Int::USize | Int::ISize)
-                    | Type::FnPtr(_) => (),
+                    Type::Ptr(inner) | Type::Ref(inner) => {
+                        if asm[inner].is_gcref(asm) {
+                            return Err(TypeCheckError::ManagedPtrCast {
+                                src: arg_tpe.mangle(asm),
+                                dst: res.as_ref().as_type().mangle(asm),
+                            });
+                        }
+                    }
+
+                    Type::Int(Int::USize | Int::ISize) | Type::FnPtr(_) => (),
                     _ => Err(TypeCheckError::InvalidPtrCast {
                         expected: res.as_ref().clone(),
                         got: arg_tpe,
                     })?,
                 };
+                if res.as_ref().as_type().is_gcref(asm) {
+                    return Err(TypeCheckError::ManagedPtrCast {
+                        src: arg_tpe.mangle(asm),
+                        dst: res.as_ref().as_type().mangle(asm),
+                    });
+                }
                 Ok(res.as_ref().as_type())
             }
             CILNode::LdFieldAdress { addr, field } => {
diff --git a/rustc_codegen_clr_ctx/src/lib.rs b/rustc_codegen_clr_ctx/src/lib.rs
@@ -2,15 +2,18 @@
 extern crate rustc_abi;
 extern crate rustc_driver;
 extern crate rustc_middle;
+extern crate rustc_span;
 use cilly::Assembly;
 use rustc_middle::ty::SymbolName;
 use rustc_middle::ty::layout::HasTypingEnv;
 use rustc_middle::ty::{Instance, PseudoCanonicalInput, TyCtxt};
+use rustc_span::Span;
 pub struct MethodCompileCtx<'tcx, 'asm> {
     tcx: TyCtxt<'tcx>,
     method: Option<&'tcx rustc_middle::mir::Body<'tcx>>,
     method_instance: Instance<'tcx>,
     asm: &'asm mut Assembly,
+    span: Option<Span>,
 }
 
 impl std::ops::DerefMut for MethodCompileCtx<'_, '_> {
@@ -29,6 +32,9 @@ impl<'asm> std::ops::Deref for MethodCompileCtx<'_, 'asm> {
 }
 
 impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {
+    pub fn set_span(&mut self, span: Span) {
+        self.span = Some(span);
+    }
     #[must_use]
     /// Creates a [`MethodCompileCtx`] with a certain MIR body.
     pub fn with_body<'a: 'asm>(&'a mut self, body: &'tcx rustc_middle::mir::Body<'tcx>) -> Self {
@@ -41,6 +47,7 @@ impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {
             method: Some(body),
             method_instance: self.method_instance,
             asm: self.asm,
+            span: Some(body.span),
         }
     }
     pub fn new(
@@ -54,8 +61,12 @@ impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {
             method,
             method_instance,
             asm,
+            span: None,
         }
     }
+    pub fn span(&self) -> Span {
+        self.span.unwrap()
+    }
     pub fn tcx_and_asm(&mut self) -> (TyCtxt<'tcx>, &mut Assembly) {
         (self.tcx, self.asm)
     }
diff --git a/rustc_codegen_clr_type/src/type.rs b/rustc_codegen_clr_type/src/type.rs
diff --git a/src/assembly.rs b/src/assembly.rs
diff --git a/src/binop/bitop.rs b/src/binop/bitop.rs
diff --git a/src/compile_test.rs b/src/compile_test.rs
