Compleate revamp of constant data handling

Author: FractalFir

cilly/src/cil_iter.rs

@@ -149,7 +149,7 @@ impl<'a> Iterator for CILIter<'a> {
                     | CILNode::LDFtn(_)
                     | CILNode::LDTypeToken(_)
                     | CILNode::LocAllocAligned { tpe: _, align: _ }
-                    | CILNode::LoadGlobalAllocPtr { alloc_id: _ }
+                    | CILNode::LoadGlobalAllocPtr { .. }
                     | CILNode::LoadAddresOfTMPLocal
                     | CILNode::PointerToConstValue(_)
                     | CILNode::LoadTMPLocal

cilly/src/cil_iter_mut.rs

@@ -171,7 +171,7 @@ impl<'a> Iterator for CILIterMut<'a> {
                     | CILNode::LoadAddresOfTMPLocal
                     | CILNode::LoadTMPLocal
                     | CILNode::LocAllocAligned { tpe: _, align: _ }
-                    | CILNode::LoadGlobalAllocPtr { alloc_id: _ }
+                    | CILNode::LoadGlobalAllocPtr { .. }
                     | CILNode::PointerToConstValue(_)
                     | CILNode::GetException
                     | CILNode::V2(_) => {

cilly/src/cil_node.rs

@@ -4,6 +4,7 @@ use crate::cilnode::MethodKind;
 use crate::v2::method::LocalDef;
 
 use crate::FieldDesc;
+use crate::IntoAsmIndex;
 use crate::{
     call,
     cil_root::CILRoot,
@@ -137,6 +138,7 @@ pub enum CILNode {
     LdcF32(HashableF32),
     LoadGlobalAllocPtr {
         alloc_id: u64,
+        tpe: Interned<Type>,
     },
     ConvU8(Box<Self>),
     ConvU16(Box<Self>),
@@ -225,6 +227,15 @@ pub enum CILNode {
 }
 
 impl CILNode {
+    pub fn global_alloc_ptr(
+        alloc_id: u64,
+        tpe: impl IntoAsmIndex<Interned<Type>>,
+        asm: &mut Assembly,
+    ) -> Self {
+        let tmp = tpe.into_idx(asm);
+        //assert!(!asm[tmp].is_ptr(), "{}", asm[tmp].mangle(asm));
+        Self::LoadGlobalAllocPtr { alloc_id, tpe: tmp }
+    }
     pub fn stack_addr(val: Self, tpe_idx: Interned<Type>, _asm: &mut Assembly) -> Self {
         CILNode::TemporaryLocal(Box::new((
             tpe_idx,
@@ -459,7 +470,7 @@ impl CILNode {
             Self::LocAllocAligned {..}=>(),
             Self::CastPtr { val, new_ptr: _ }=>val.allocate_tmps(curr_loc, locals),
             Self:: PointerToConstValue(_arr)=>(),
-            Self::LoadGlobalAllocPtr { alloc_id: _ } => (),
+            Self::LoadGlobalAllocPtr { alloc_id: _,tpe:_ } => (),
             Self::LDLoc(_) |
             Self::LDArg(_) |
             Self::LDLocA(_)|

cilly/src/v2/asm.rs

@@ -1449,6 +1449,10 @@ impl Assembly {
     pub(crate) fn alloc_const_data(&mut self, data: &[u8]) -> Interned<Box<[u8]>> {
         self.const_data.alloc(data.into())
     }
+
+    pub(crate) fn char_is_u8(&self) -> bool {
+        true
+    }
 }
 config!(GUARANTED_ALIGN, u8, 8);
 config!(MAX_STATIC_SIZE, usize, 16);

cilly/src/v2/c_exporter/mod.rs

@@ -1296,12 +1296,23 @@ impl CExporter {
         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 data: String = match str::from_utf8(const_data) {
+                Ok(s)
+                    if asm.char_is_u8()
+                        && s.chars().all(|c| {
+                            c.is_ascii_graphic() || matches!(c, '\0' | ' ' | '\n' | '\t' | '\r')
+                        }) =>
+                {
+                    format!("{s:?}")
+                }
+                Ok(_) | Err(_) => 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

cilly/src/v2/tpe/mod.rs

@@ -287,4 +287,12 @@ impl Type {
             None
         }
     }
+
+    /// Returns `true` if the type is [`Ptr`].
+    ///
+    /// [`Ptr`]: Type::Ptr
+    #[must_use]
+    pub fn is_ptr(&self) -> bool {
+        matches!(self, Self::Ptr(..))
+    }
 }

rustc_codegen_clr_ctx/src/lib.rs

@@ -65,7 +65,7 @@ impl<'tcx, 'asm> MethodCompileCtx<'tcx, 'asm> {
         }
     }
     pub fn span(&self) -> Span {
-        self.span.unwrap()
+        self.span.unwrap_or(Span::default())
     }
     pub fn tcx_and_asm(&mut self) -> (TyCtxt<'tcx>, &mut Assembly) {
         (self.tcx, self.asm)

rustc_codegen_clr_type/src/type.rs

@@ -327,13 +327,14 @@ pub fn get_type<'tcx>(ty: Ty<'tcx>, ctx: &mut MethodCompileCtx<'tcx, '_>) -> Typ
     }
 }
 //
-fn fixed_array(
+pub fn fixed_array(
     asm: &mut Assembly,
     element: Type,
     length: u64,
     arr_size: u64,
     align: u64,
 ) -> Interned<ClassRef> {
+    assert_ne!(arr_size, 0);
     // Get the reference to the array class
     let cref = ClassRef::fixed_array(element, length, asm);