Small linker fixes

Author: FractalFir

cilly/src/v2/asm.rs

@@ -938,7 +938,7 @@ impl Assembly {
             .collect();
         for index in 0..mref_count {
             // Get the full method refernce
-            let mref = &self.method_refs.0[index];
+            let mref = self.method_refs.0[index].clone();
             // Check if this method reference's class has an assembly. If it has, then the method is extern. If it has not, then it is defined in this assembly
             // and must have some kind of implementation
             let class = self.class_ref(mref.class());
@@ -993,13 +993,19 @@ impl Assembly {
             let arg_names = (0..(self[mref.sig()].inputs().len()))
                 .map(|_| None)
                 .collect();
+            let imp = if self[mref.name()].contains("__rust_alloc") && !self[mref.name()].contains("__rust_alloc_error_handler"){
+                let mref = MethodRef::aligned_alloc(self);
+                MethodImpl::wrapper(self.alloc_methodref(mref),self)
+            }else{
+                MethodImpl::Missing
+            };
             let method_def = MethodDef::new(
                 Access::Public,
                 ClassDefIdx(mref.class()),
                 mref.name(),
                 mref.sig(),
                 mref.kind(),
-                MethodImpl::Missing,
+                imp,
                 arg_names,
             );
             assert!(

cilly/src/v2/c_exporter/mod.rs

@@ -1049,11 +1049,19 @@ impl CExporter {
                 writeln!(type_defs, "{field_tpe} {fname};")?;
             }
             if last_offset != class.explict_size().unwrap().get() {
-                writeln!(
-                    type_defs,
-                    "uint8_t pad_{pad_count}[{}];\n",
-                    class.explict_size().unwrap().get() - last_offset
-                )?;
+                let size = class.explict_size().unwrap().get();
+                if let Some((tpe,name,_)) = fields.last(){
+                    //assert!(size >= last_offset, "Type {class_name} has field offset {last_offset} larger than {size}. {} {}",tpe.mangle(asm),&asm[*name]);
+                    writeln!(
+                        type_defs,
+                        "uint8_t pad_{pad_count}[{}];\n",
+                        size.checked_sub(last_offset).unwrap_or_else(||{
+                            eprintln!("Type {class_name} has field offset {last_offset} larger than {size}. {} {}",tpe.mangle(asm),&asm[*name]);
+                            0
+                        })
+                    )?;
+                }
+                
             }
             writeln!(type_defs, "}} {class_name};")?;
         } else {

cilly/src/v2/method.rs

@@ -3,11 +3,11 @@ use serde::{Deserialize, Serialize};
 
 use super::{
     bimap::{BiMapIndex, IntoBiMapIndex},
-    cilnode::MethodKind,
+    cilnode::{IsPure, MethodKind},
     Access, Assembly, BasicBlock, CILIterElem, CILNode, ClassDefIdx, ClassRef, ClassRefIdx, Int,
     SigIdx, StringIdx, Type, TypeIdx,
 };
-use crate::v2::iter::TpeIter;
+use crate::{cil_node::CallOpArgs, v2::iter::TpeIter};
 use crate::v2::CILRoot;
 pub type LocalId = u32;
 #[derive(Hash, PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
@@ -722,6 +722,19 @@ impl MethodImpl {
         // Swap new and locals
         std::mem::swap(locals, new_locals.get_mut().unwrap());
     }
+    
+    pub(crate) fn wrapper(mref: MethodRefIdx, asm: &mut Assembly) -> MethodImpl {
+        let sig = asm[asm[mref].sig()].clone();
+        let args = sig.inputs().iter().enumerate().map(|(idx,_)|asm.alloc_node(CILNode::LdArg(idx.try_into().unwrap()))).collect();
+        let roots = if asm.sizeof_type(*sig.output()) == 0{
+            let call = asm.alloc_root(CILRoot::Call(Box::new((mref,args,  IsPure::NOT))));
+            vec![call,asm.alloc_root(CILRoot::VoidRet)]
+        } else{
+            let val = asm.alloc_node(CILNode::Call(Box::new((mref,args,  IsPure::NOT))));
+            vec![asm.alloc_root(CILRoot::Ret(val))]
+        };
+        MethodImpl::MethodBody { blocks: vec![BasicBlock::new(roots,0,None)], locals: vec![].into() }
+    }
 }
 #[derive(Hash, PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
 pub struct MethodDefIdx(pub MethodRefIdx);

cilly/src/v2/mod.rs

@@ -2,6 +2,7 @@
 #![allow(clippy::module_name_repetitions)]
 // This lint includes tests for some bizzare reason, so ignoring it seems like the best course of action
 #![allow(clippy::missing_panics_doc)]
+
 use std::path::Path;
 
 pub use access::Access;

rustc_codegen_clr_type/src/utilis.rs

@@ -156,7 +156,6 @@ pub fn tuple_name(elements: &[Type], asm: &Assembly) -> String {
 /// Creates a tuple with no more than 8 elements.
 #[must_use]
 pub fn simple_tuple(elements: &[cilly::v2::Type], asm: &mut Assembly) -> ClassRefIdx {
-    // Since no intering can happen at this stage, we can pass an empty AsmStringContainer safely.
     let name = tuple_name(elements, asm);
     let name = asm.alloc_string(name);
     asm.alloc_class_ref(ClassRef::new(name, None, true, [].into()))