Updated constants to use byte buffer literals.

Author: FractalFir

bin/c_success_coretests.txt

@@ -1456,6 +1456,7 @@ slice::memchr::no_match
 slice::memchr::no_match_empty
 slice::memchr::no_match_empty_reversed
 slice::memchr::no_match_reversed
+slice::select_nth_unstable
 slice::select_nth_unstable_past_length
 slice::select_nth_unstable_zero_length
 slice::slice_index::assert_range_eq_can_fail_by_inequality

cilly/src/v2/asm.rs

@@ -34,7 +34,7 @@ pub struct Assembly {
     method_defs: FxHashMap<MethodDefIdx, MethodDef>,
     sections: FxHashMap<String, Vec<u8>>,
     /// A list of all buffers within this assembly.
-    buffer: BiMap<Box<[u8]>>,
+    pub(crate) const_data: BiMap<Box<[u8]>>,
 }
 impl Index<Interned<IString>> for Assembly {
     type Output = str;
@@ -114,6 +114,16 @@ impl Index<Interned<FieldDesc>> for Assembly {
     }
 }
 impl Assembly {
+    /// Returns a pointer to an immutable(!) byte buffer of a given type.
+    pub fn bytebuffer(
+        &mut self,
+        buffer: &[u8],
+        tpe: impl IntoAsmIndex<Interned<Type>>,
+    ) -> Interned<CILNode> {
+        let data = self.const_data.alloc(buffer.into());
+        let tpe = tpe.into_idx(self);
+        self.alloc_node(Const::ByteBuffer { data, tpe })
+    }
     /// Offsets `addr` by `index` * sizeof(`tpe`)
     pub fn offset(
         &mut self,
@@ -1425,8 +1435,8 @@ impl Assembly {
         self.add_static(Type::Void, "global_void", false, main)
     }
 
-    pub(crate) fn translate_buffer(&self, data: Interned<Box<[u8]>>) -> Interned<Box<[u8]>> {
-        todo!()
+    pub(crate) fn alloc_const_data(&mut self, data: &[u8]) -> Interned<Box<[u8]>> {
+        self.const_data.alloc(data.into())
     }
 }
 config!(GUARANTED_ALIGN, u8, 8);
@@ -1631,7 +1641,11 @@ fn export2() {
     let main_module = asm.main_module();
     let name = asm.alloc_string("entrypoint");
     let sig = asm.sig([], Type::Void);
-    let body1 = vec![asm.alloc_root(CILRoot::VoidRet)];
+    let buff = asm.bytebuffer(b"Hewwo!", Int::U8);
+    let body1 = vec![
+        asm.alloc_root(CILRoot::VoidRet),
+        asm.alloc_root(CILRoot::Pop(buff)),
+    ];
     let hbody = vec![asm.alloc_root(CILRoot::ExitSpecialRegion {
         target: 2,
         source: 0,

cilly/src/v2/asm_link.rs

@@ -114,7 +114,7 @@ impl Assembly {
                 super::Const::ByteBuffer { data, tpe } => {
                     let tpe = self.translate_type(source, source[*tpe]);
                     CILNode::Const(Box::new(super::Const::ByteBuffer {
-                        data: self.translate_buffer(*data),
+                        data: self.alloc_const_data(&source.const_data[*data]),
                         tpe: self.alloc_type(tpe),
                     }))
                 }

cilly/src/v2/c_exporter/mod.rs

@@ -1236,6 +1236,11 @@ impl CExporter {
         let mut defined_types: FxHashSet<ClassDefIdx> = FxHashSet::default();
         let mut delayed_defs: FxHashSet<ClassDefIdx> = asm.iter_class_def_ids().cloned().collect();
         let mut delayed_defs_copy: FxHashSet<ClassDefIdx> = FxHashSet::default();
+        for (const_data, idx) in asm.const_data.1.iter() {
+            let data: String = const_data.iter().map(|u| format!("{u}")).intersperse(",".into()).collect();
+            let encoded = encode(idx.inner() as u64);
+            writeln!(type_defs, "uint8_t c_{encoded}[] = {{{data}}};")?;
+        }
         // Ensure RustVoid present
         let rust_void = asm.rust_void();
         self.export_class(
@@ -1310,6 +1315,7 @@ impl CExporter {
         extrn: bool,
         is_main: bool,
     ) -> Result<(), std::io::Error> {
+     
         let mut c_out = std::io::BufWriter::new(std::fs::File::create(c_path)?);
         println!("Exporting {c_path:?}");
 

cilly/src/v2/il_exporter/mod.rs

@@ -1,4 +1,7 @@
-use crate::{utilis::assert_unique, MethodImpl};
+use crate::{
+    utilis::{assert_unique, encode},
+    MethodImpl,
+};
 
 use std::{io::Write, path::Path};
 
@@ -27,6 +30,11 @@ impl ILExporter {
     fn export_to_write(&self, asm: &super::Assembly, out: &mut impl Write) -> std::io::Result<()> {
         let asm_mut = &mut asm.clone();
         writeln!(out, ".assembly _{{}}")?;
+        for (const_data, idx) in asm.const_data.1.iter() {
+            let encoded = encode(idx.inner() as u64);
+            let data: String = const_data.iter().map(|u| format!("{u:x} ")).collect();
+            writeln!(out, " .data cil I_{encoded} = bytearray ({data})\n.field assembly static uint8 c_{encoded} at I_{encoded}")?;
+        }
         // Iterate trough all types
         for class_def in asm.iter_class_defs() {
             let vis = match class_def.access() {
@@ -251,8 +259,8 @@ impl ILExporter {
         let node = asm.get_node(node).clone();
         match node {
             CILNode::Const(cst) => match cst.as_ref() {
-                super::Const::ByteBuffer { data, tpe }=>{
-                    todo!("ByteBuffers not supported in IL yet.")
+                super::Const::ByteBuffer { data, tpe:_ }=>{
+                    writeln!(out,"ldsflda uint8 c_{}", encode(data.inner() as u64))
                 }
                 super::Const::Null(_) => writeln!(out, "ldnull"),
                 super::Const::I8(val) => match val {

rustc_codgen_clr_operand/src/constant.rs

@@ -58,6 +58,15 @@ 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 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 ptr = CILNode::LoadGlobalAllocPtr {
         alloc_id: alloc_id.0.into(),
@@ -93,9 +102,9 @@ pub fn load_const_value<'tcx>(
             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: u64 = alloc_id.0.into();
+
             let meta = CILNode::V2(ctx.alloc_node(Const::USize(meta)));
-            let ptr = CILNode::LoadGlobalAllocPtr { alloc_id }.cast_ptr(ctx.nptr(Type::Void));
+            let ptr = alloc_ptr(alloc_id, &data, ctx).cast_ptr(ctx.nptr(Type::Void));
             CILNode::create_slice(slice_dotnet, ctx, meta, ptr)
         }
         ConstValue::Indirect { alloc_id, offset } => {
@@ -172,21 +181,16 @@ fn load_scalar_ptr(
             let alloc_id = alloc_id.alloc_id().0.into();
             CILNode::LoadGlobalAllocPtr { alloc_id }
         }
-        GlobalAlloc::Memory(_const_allocation) => {
+        GlobalAlloc::Memory(const_allocation) => {
             if offset.bytes() != 0 {
                 CILNode::Add(
-                    CILNode::LoadGlobalAllocPtr {
-                        alloc_id: alloc_id.alloc_id().0.into(),
-                    }
-                    .into(),
+                    alloc_ptr(alloc_id.alloc_id(), &const_allocation, ctx).into(),
                     Box::new(CILNode::V2(
                         ctx.alloc_node(cilly::Const::USize(offset.bytes())),
                     )),
                 )
             } else {
-                CILNode::LoadGlobalAllocPtr {
-                    alloc_id: alloc_id.alloc_id().0.into(),
-                }
+                alloc_ptr(alloc_id.alloc_id(), &const_allocation, ctx)
             }
         }
         GlobalAlloc::Function {
@@ -217,6 +221,24 @@ fn load_scalar_ptr(
     }
     //panic!("alloc_id:{alloc_id:?}")
 }
+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();
+    // 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 {
+        CILNode::LoadGlobalAllocPtr {
+            alloc_id: alloc_id.0.into(),
+        }
+    }
+}
 fn load_const_scalar<'tcx>(
     scalar: Scalar,
     scalar_type: Ty<'tcx>,

src/assembly.rs

@@ -132,74 +132,17 @@ fn allocation_initializer_method(
         );
     }
 
-    if !bytes.iter().all(|byte| *byte != 0) {
-        trees.push(
-            CILRoot::InitBlk {
-                dst: Box::new(CILNode::LDLoc(0)),
-                val: Box::new(CILNode::V2(asm.alloc_node(0_u8))),
-                count: Box::new(CILNode::V2(
-                    asm.alloc_node(Const::USize(bytes.len() as u64)),
-                )),
-            }
-            .into(),
-        );
-    }
-    let mut offset = 0;
-    while offset < bytes.len() {
-        let reminder = bytes.len() - offset;
-        match reminder {
-            8.. => {
-                let long = u64::from_ne_bytes(bytes[offset..(offset + 8)].try_into().unwrap());
-                if long != 0 {
-                    trees.push(
-                        CILRoot::STIndI64(
-                            (CILNode::LDLoc(0)
-                                + CILNode::V2(
-                                    asm.alloc_node(Const::USize(offset.try_into().unwrap())),
-                                ))
-                            .cast_ptr(asm.nptr(Type::Int(Int::U64))),
-                            CILNode::V2(asm.alloc_node(long)),
-                        )
-                        .into(),
-                    );
-                }
-                offset += 8;
-            }
-            4.. => {
-                let long = u32::from_ne_bytes(bytes[offset..(offset + 4)].try_into().unwrap());
-                if long != 0 {
-                    trees.push(
-                        CILRoot::STIndI32(
-                            (CILNode::LDLoc(0)
-                                + CILNode::V2(
-                                    asm.alloc_node(Const::USize(offset.try_into().unwrap())),
-                                ))
-                            .cast_ptr(asm.nptr(Type::Int(Int::U32))),
-                            CILNode::V2(asm.alloc_node(long)),
-                        )
-                        .into(),
-                    );
-                }
-                offset += 4;
-            }
-            _ => {
-                let byte = bytes[offset];
-                if byte != 0 {
-                    trees.push(
-                        CILRoot::STIndI8(
-                            CILNode::LDLoc(0)
-                                + CILNode::V2(
-                                    asm.alloc_node(Const::USize(offset.try_into().unwrap())),
-                                ),
-                            CILNode::V2(asm.alloc_node(byte)),
-                        )
-                        .into(),
-                    );
-                }
-                offset += 1;
-            }
+    trees.push(
+        CILRoot::CpBlk {
+            dst: Box::new(CILNode::LDLoc(0)),
+            src: Box::new(CILNode::V2(asm.bytebuffer(bytes, Int::U8))),
+            len: Box::new(CILNode::V2(
+                asm.alloc_node(Const::USize(bytes.len() as u64)),
+            )),
         }
-    }
+        .into(),
+    );
+
     if !ptrs.is_empty() {
         for (offset, prov) in ptrs.iter() {
             let offset = u32::try_from(offset.bytes_usize()).unwrap();

test/types/nbody.rs

@@ -83,7 +83,7 @@ struct RNG {
 }
 impl RNG {
     fn next_i16(&mut self) -> i16 {
-        self.state = 214013 * self.state + 2531011;
+        self.state = 214013_i32.wrapping_mul(self.state).wrapping_add(2531011);
         return ((self.state >> 16) & 0xFFFF) as i16;
     }
     fn next_f32(&mut self) -> f32 {