Changes to const allocations - they will now more often use const buffers, even when they are underaligned. Updated readme.

FractalFir · FractalFir · commit 9762de121927 · 2025-04-14T19:34:22.000+02:00
diff --git a/README.md b/README.md
@@ -77,7 +77,7 @@ However, if you have access to such a compiler, I can assist you in adding suppo
 
 | Name | Pass	| Faliure	| Crash \ Timeout| OK precentage
 |--------------------|--------|-------|-------|------|
-| Core tests |	1662	| 39	| 12	| 97.02% |
+| Core tests |	1764	| 48	| 20	| 96.29% |
 | Alloc tests | 	616	|8 |	40 |	92.77% |
 | Alloc benches	| 464	| 0	| 0 |	100.00% |
 | Test Harness tests |	57 |	0	| 100.00% |
@@ -86,9 +86,9 @@ However, if you have access to such a compiler, I can assist you in adding suppo
 
 C
 
-| Name | Pass	| Faliure	| OK precentage
-|--------------------|--------|-------|------|
-| Core tests |	1419	| 294	| 82.83% |
+| Name | Pass	| Faliure| Crash \ Timeout | OK precentage
+|--------------------|--------|------|-------|------|
+| Core tests |	1712	| 71 | 8 | 95.59%|
 
 ## FAQ
 
diff --git a/cilly/src/bin/linker/main.rs b/cilly/src/bin/linker/main.rs
@@ -434,6 +434,8 @@ fn main() {
     cilly::builtins::select::generate_int_selects(&mut final_assembly, &mut overrides);
     cilly::builtins::insert_swap_at_generic(&mut final_assembly, &mut overrides);
     cilly::builtins::insert_bounds_check(&mut final_assembly, &mut overrides);
+    cilly::builtins::unaligned_read(&mut final_assembly, &mut overrides);
+
     cilly::builtins::casts::insert_casts(&mut final_assembly, &mut overrides);
     cilly::builtins::insert_heap(&mut final_assembly, &mut overrides, *C_MODE);
     cilly::builtins::rust_assert(&mut final_assembly, &mut overrides);
diff --git a/cilly/src/v2/builtins/mod.rs b/cilly/src/v2/builtins/mod.rs
@@ -65,6 +65,26 @@ pub fn insert_bounds_check(asm: &mut Assembly, patcher: &mut MissingMethodPatche
     };
     patcher.insert(name, Box::new(generator));
 }
+pub fn unaligned_read(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
+    let name = asm.alloc_string("unaligned_read");
+    let generator = move |mref: Interned<MethodRef>, asm: &mut Assembly| {
+        let tpe = asm[asm[mref].sig()].output();
+        let tpe = asm.alloc_type(*tpe);
+        // Copy to a local
+        let ptr = asm.alloc_node(CILNode::LdArg(0));
+        let local = asm.alloc_node(CILNode::LdLocA(0));
+        let size = asm.size_of(tpe);
+        let copy = asm.alloc_root(CILRoot::CpBlk(Box::new((local, ptr, size))));
+        // Ret
+        let local = asm.alloc_node(CILNode::LdLoc(0));
+        let ret = asm.alloc_root(CILRoot::Ret(local));
+        MethodImpl::MethodBody {
+            blocks: vec![BasicBlock::new(vec![copy, ret], 0, None)],
+            locals: vec![(None, tpe)],
+        }
+    };
+    patcher.insert(name, Box::new(generator));
+}
 
 fn insert_rust_alloc(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
     let name = asm.alloc_string("__rust_alloc");
diff --git a/cilly/src/v2/c_exporter/utilis.rs b/cilly/src/v2/c_exporter/utilis.rs
@@ -133,6 +133,7 @@ pub(super) fn mref_to_name(mref: &MethodRef, asm: &Assembly) -> String {
             .any(|tpe| matches!(tpe, Type::SIMDVector(_)))
         || mname == "transmute"
         || mname == "create_slice"
+        || mname == "unaligned_read"
         || mname == "ovf_check_tuple"
         || mname == "_Unwind_Backtrace"
     {
diff --git a/cilly/src/v2/method.rs b/cilly/src/v2/method.rs
@@ -5,7 +5,8 @@ use super::{
     bimap::{BiMapIndex, Interned, IntoBiMapIndex},
     cilnode::{IsPure, MethodKind},
     class::ClassDefIdx,
-    Access, Assembly, BasicBlock, CILIterElem, CILNode, ClassDef, ClassRef, FnSig, Int, Type,
+    Access, Assembly, BasicBlock, CILIterElem, CILNode, ClassDef, ClassRef, FnSig, Int,
+    IntoAsmIndex, Type,
 };
 use crate::{cil_node::CallOpArgs, cilnode::PtrCastRes, iter::TpeIter};
 use crate::{CILRoot, IString};
@@ -18,7 +19,24 @@ pub struct MethodRef {
     kind: MethodKind,
     generics: Box<[Type]>,
 }
-
+impl Interned<MethodRef> {
+    pub fn builtin(
+        asm: &mut Assembly,
+        name: &str,
+        inputs: &[Type],
+        output: impl IntoAsmIndex<Type>,
+    ) -> Self {
+        let main_module = asm.main_module();
+        let inputs: Box<_> = inputs.to_vec().into();
+        let output = output.into_idx(asm);
+        let sig = asm.alloc_sig(FnSig::new(inputs, output));
+        asm.new_methodref(*main_module, name, sig, MethodKind::Static, [])
+    }
+    pub fn unaligned_read(asm: &mut Assembly, tpe: Type) -> Self {
+        let tpe_ptr = asm.alloc_type(tpe);
+        Self::builtin(asm, "unaligned_read", &[Type::Ptr(tpe_ptr)], tpe)
+    }
+}
 impl MethodRef {
     #[must_use]
     pub fn into_def(
diff --git a/rustc_codegen_clr_ctx/src/lib.rs b/rustc_codegen_clr_ctx/src/lib.rs
@@ -107,6 +107,10 @@ impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {
     pub fn asm<'s: 'a, 'a>(&'s self) -> &'a Assembly {
         self.asm
     }
+
+    pub fn const_align(&self) -> u64 {
+        1
+    }
 }
 impl<'tcx> rustc_middle::ty::layout::HasTyCtxt<'tcx> for MethodCompileCtx<'tcx, '_> {
     fn tcx(&self) -> TyCtxt<'tcx> {
diff --git a/rustc_codgen_clr_operand/src/constant.rs b/rustc_codgen_clr_operand/src/constant.rs
@@ -58,15 +58,25 @@ fn create_const_from_data<'tcx>(
                 Scalar::from_u128(u128::from_ne_bytes(bytes.as_slice().try_into().unwrap()));
             return load_const_scalar(scalar, ty, ctx);
         }
-        let ptr = alloc_ptr(alloc_id, &alloc, ctx);
-        let ty = ctx.monomorphize(ty);
+        let (ptr, align) = alloc_ptr_unaligned(alloc_id, &alloc, ctx);
+        if align == u64::MAX {
+            let ty = ctx.monomorphize(ty);
 
-        let tpe = ctx.type_from_cache(ty);
-        let tpe_ptr = ctx.nptr(tpe);
-        return CILNode::LdObj {
-            ptr: Box::new(ptr.cast_ptr(tpe_ptr)),
-            obj: Box::new(tpe),
-        };
+            let tpe = ctx.type_from_cache(ty);
+            let tpe_ptr = ctx.nptr(tpe);
+            return CILNode::LdObj {
+                ptr: Box::new(ptr.cast_ptr(tpe_ptr)),
+                obj: Box::new(tpe),
+            };
+        } else {
+            let ty = ctx.monomorphize(ty);
+
+            let tpe = ctx.type_from_cache(ty);
+            let tpe_ptr = ctx.nptr(tpe);
+
+            let unaligned_read = Interned::unaligned_read(ctx, tpe);
+            return call!(unaligned_read, [ptr.cast_ptr(tpe_ptr)]);
+        }
     }
     let ptr = CILNode::LoadGlobalAllocPtr {
         alloc_id: alloc_id.0.into(),
@@ -221,22 +231,64 @@ fn load_scalar_ptr(
     }
     //panic!("alloc_id:{alloc_id:?}")
 }
+/// Returns a pointer to an immutable buffer, representing a given allocation.
 fn alloc_ptr<'tcx>(
     alloc_id: AllocId,
     const_alloc: &rustc_middle::mir::interpret::ConstAllocation,
     ctx: &mut MethodCompileCtx<'tcx, '_>,
 ) -> CILNode {
-    let const_alloc = const_alloc.inner();
+    let (ptr, align) = alloc_ptr_unaligned(alloc_id, const_alloc, ctx);
     // If aligement is small enough to be *guaranteed*, and no pointers are present.
-    if const_alloc.align.bytes() <= 1 && const_alloc.provenance().ptrs().is_empty() {
-        CILNode::V2(ctx.bytebuffer(
-            const_alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..const_alloc.len()),
-            Int::U8,
-        ))
-    } else {
+    if align == u64::MAX || align <= ctx.const_align() {
         CILNode::LoadGlobalAllocPtr {
             alloc_id: alloc_id.0.into(),
         }
+    } else {
+        ptr
+    }
+}
+/// Returns a pointer to an immutable buffer, representing a given allocation. Pointer may be underaligned, aligement of `u64::MAX` signals that the pointer
+/// will be sufficently aligned for `const_alloc`.
+fn alloc_ptr_unaligned<'tcx>(
+    alloc_id: AllocId,
+    const_alloc: &rustc_middle::mir::interpret::ConstAllocation,
+    ctx: &mut MethodCompileCtx<'tcx, '_>,
+) -> (CILNode, u64) {
+    let const_alloc = const_alloc.inner();
+    // If aligement is small enough to be *guaranteed*, and no pointers are present.
+    if const_alloc.provenance().ptrs().is_empty() {
+        if const_alloc.align.bytes() <= ctx.const_align() {
+            //unaligned_read
+            (
+                CILNode::V2(
+                    ctx.bytebuffer(
+                        const_alloc
+                            .inspect_with_uninit_and_ptr_outside_interpreter(0..const_alloc.len()),
+                        Int::U8,
+                    ),
+                ),
+                u64::MAX,
+            )
+        } else {
+            //unaligned_read
+            (
+                CILNode::V2(
+                    ctx.bytebuffer(
+                        const_alloc
+                            .inspect_with_uninit_and_ptr_outside_interpreter(0..const_alloc.len()),
+                        Int::U8,
+                    ),
+                ),
+                ctx.const_align(),
+            )
+        }
+    } else {
+        (
+            CILNode::LoadGlobalAllocPtr {
+                alloc_id: alloc_id.0.into(),
+            },
+            u64::MAX,
+        )
     }
 }
 fn load_const_scalar<'tcx>(

Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,7 @@ pub(super) fn mref_to_name(mref: &MethodRef, asm: &Assembly) -> String {`
`133`	`133`	`.any(\|tpe\| matches!(tpe, Type::SIMDVector(_)))`
`134`	`134`	`\|\| mname == "transmute"`
`135`	`135`	`\|\| mname == "create_slice"`
	`136`	`+ \|\| mname == "unaligned_read"`
`136`	`137`	`\|\| mname == "ovf_check_tuple"`
`137`	`138`	`\|\| mname == "_Unwind_Backtrace"`
`138`	`139`	`{`
Original file line number	Diff line number	Diff line change
`@@ -107,6 +107,10 @@ impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {`
`107`	`107`	`pub fn asm<'s: 'a, 'a>(&'s self) -> &'a Assembly {`
`108`	`108`	`self.asm`
`109`	`109`	`}`
	`110`	`+`
	`111`	`+ pub fn const_align(&self) -> u64 {`
	`112`	`+ 1`
	`113`	`+ }`
`110`	`114`	`}`
`111`	`115`	`impl<'tcx> rustc_middle::ty::layout::HasTyCtxt<'tcx> for MethodCompileCtx<'tcx, '_> {`
`112`	`116`	`fn tcx(&self) -> TyCtxt<'tcx> {`