More LCC support

Author: FractalFir

cilly/src/v2/asm.rs

@@ -1320,7 +1320,17 @@ impl Assembly {
     pub(crate) fn get_section(&self, arg: &str) -> Option<&Vec<u8>> {
         self.sections.get(arg)
     }
+    
+    pub(crate) fn guaranted_align(&self) -> u8 {
+        *GUARANTED_ALIGN
+    }
+    
+    pub fn max_static_size(&self) -> usize {
+        *MAX_STATIC_SIZE
+    }
 }
+config!(GUARANTED_ALIGN, u8,8);
+config!(MAX_STATIC_SIZE, usize,16);
 /// An initializer, which runs before everything else. By convention, it is used to initialize static / const data. Should not execute any user code
 pub const CCTOR: &str = ".cctor";
 /// An thread-local initializer. Runs before each thread starts. By convention, it is used to initialize thread local data. Should not execute any user code.

cilly/src/v2/c_exporter/c_header.h

@@ -1,6 +1,12 @@
 #include <stdio.h>
 #include <stdint.h>
-
+/* Backup for targets that don't support i128 - TODO: replace this with software emulation!*/
+#if !defined(__SIZEOF_INT128__) || defined(__LCC__)
+#define __int128_t long long
+#define __int128 __int128_t
+#define __uint128_t unsigned long long
+#define uint128_t unsigned long long
+#endif
 #if !defined(__TINYC__) && !defined(__LCC__)
 #include <stdbool.h>
 #elif defined(__LCC__)
@@ -12,7 +18,9 @@
 #define false 0
 #define true 1
 #endif
-
+#ifdef __LCC__
+#define __func__ "unknown"
+#endif
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -39,18 +47,20 @@ inline void* _mm_malloc(size_t size, size_t align){
 inline void _mm_free (void *p){
     free(p);
 }
+#endif
+#if (defined(__TINYC__) || defined(__SDCC) || defined(__LCC__))
 inline uint16_t __builtin_bswap16(uint16_t val){
     uint16_t res;
-    uint8_t* ptr = &val;
-    uint8_t* rptr = &res;
+    uint8_t* ptr = (uint8_t*)&val;
+    uint8_t* rptr = (uint8_t*)&res;
     rptr[0] = ptr[1];
     rptr[1] = ptr[0];
     return res;
 }
 inline uint32_t __builtin_bswap32(uint32_t val){
     uint32_t res;
-    uint8_t* ptr = &val;
-    uint8_t* rptr = &res;
+    uint8_t* ptr = (uint8_t*)&val;
+    uint8_t* rptr = (uint8_t*)&res;
     rptr[0] = ptr[3];
     rptr[1] = ptr[2];
     rptr[2] = ptr[1];
@@ -59,8 +69,8 @@ inline uint32_t __builtin_bswap32(uint32_t val){
 }
 inline uint64_t __builtin_bswap64(uint64_t val){
     uint64_t res;
-    uint8_t* ptr = &val;
-    uint8_t* rptr = &res;
+    uint8_t* ptr = (uint8_t*)&val;
+    uint8_t* rptr = (uint8_t*)&res;
     rptr[0] = ptr[7];
     rptr[1] = ptr[6];
     rptr[2] = ptr[5];
@@ -71,6 +81,28 @@ inline uint64_t __builtin_bswap64(uint64_t val){
     rptr[7] = ptr[0];
     return res;
 }
+inline uint128_t __builtin_bswap128(uint128_t val){
+    uint128_t res;
+    uint8_t* ptr = (uint8_t*)&val;
+    uint8_t* rptr = (uint8_t*)&res;
+    rptr[0] = ptr[15];
+    rptr[1] = ptr[14];
+    rptr[2] = ptr[13];
+    rptr[3] = ptr[12];
+    rptr[4] = ptr[11];
+    rptr[5] = ptr[10];
+    rptr[6] = ptr[9];
+    rptr[7] = ptr[8];
+    rptr[8] = ptr[7];
+    rptr[9] = ptr[6];
+    rptr[10] = ptr[5];
+    rptr[11] = ptr[4];
+    rptr[12] = ptr[3];
+    rptr[13] = ptr[2];
+    rptr[14] = ptr[1];
+    rptr[16] = ptr[0];
+    return res;
+}
 #endif
 #ifdef __clang__
 static inline __uint128_t __builtin_bswap128(__uint128_t val){
@@ -115,41 +147,41 @@ __uint128_t __builtin_bswap128(__uint128_t val);
 #define FORCE_NOT_ZST char force_not_zst;
 #endif
 
-#if !(defined(__SDCC) || defined(_MSC_VER))
+#if !(defined(__SDCC) || defined(_MSC_VER) || defined(__LCC__))
 #include <alloca.h>
+#define register_alloca_aligned(type, align, hash)
+#define loc_alloc_aligned(name, type, align, hash) name = (void*)((((size_t)(alloca(sizeof(type) + align) + align - 1)) / align)*align);
 #elif defined(_MSC_VER)
 #define alloca _alloca
+#define register_alloca_aligned(type, align, hash)
+#define loc_alloc_aligned(name, type, align, hash) name = (void*)((((size_t)(alloca(sizeof(type) + align) + align - 1)) / align)*align);
 #else
-#define alloca(arg) ((void*)0)
-#endif
-/* Backup for targets that don't support i128 - TODO: replace this with software emulation!*/
-#if !defined(__SIZEOF_INT128__) || defined(__LCC__)
-#define __int128_t long long
-#define __int128 __int128_t
-#define __uint128_t unsigned long long
+#define register_alloca_aligned(type, align, hash) char hash[sizeof(type) + align];  
+#define loc_alloc_aligned(name, type, align, hash) name = (void*)((((size_t)(&hash + align - 1)) / align)*align); 
 #endif
+
 #ifdef __clang__
 #define __atomic_compare_exchange_4 __atomic_compare_exchange_n
 #define __atomic_compare_exchange_8 __atomic_compare_exchange_n
 #define _Float128 long double
-#elif defined(__SDCC)
+#elif (defined(__SDCC) || defined(__LCC__))
 // WARNING! Assumes a single-threaded, no-interrupt eviroment!
 bool __atomic_compare_exchange_4(uint32_t *ptr, uint32_t *expected, uint32_t desired, bool weak, int success_memorder, int failure_memorder){
-    if(*ptr == expected){
+    if(*ptr == *expected){
         *ptr = desired;
         return true;
     }
     return false;
 }
 bool __atomic_compare_exchange_8(uint64_t *ptr, uint64_t *expected, uint64_t desired, bool weak, int success_memorder, int failure_memorder){
-    if(*ptr == expected){
+    if(*ptr == *expected){
         *ptr = desired;
         return true;
     }
     return false;
 }
 bool __atomic_compare_exchange_n(uintptr_t *ptr, uintptr_t *expected, uintptr_t desired, bool weak, int success_memorder, int failure_memorder){
-    if(*ptr == expected){
+    if(*ptr == *expected){
         *ptr = desired;
         return true;
     }
@@ -195,7 +227,7 @@ static inline void *System_Runtime_InteropServices_NativeMemory_AlignedReallocpv
 #define eprintf(...) printf(__VA_ARGS__)
 #define BUILTIN_UNSUPORTED(NAME,OUTPUT, ARGLIST) static inline OUTPUT NAME ARGLIST { eprintf("Function " #NAME "is not yet supported!"); abort();}
 #endif
-#ifdef __SDCC
+#if defined(__SDCC) || defined(__LCC__)
 #define NAN (0.0 / 0.0)
 #endif
 #ifdef __SDCC
@@ -326,7 +358,7 @@ static inline __uint128_t System_UInt128_op_Explicitf64u128(double val) {
 /*Assumes a 64 bit OS.*/
 #define System_Buffers_Binary_BinaryPrimitives_ReverseEndiannessisizeisize(val) (intptr_t) __builtin_bswap64((uint64_t)val)
 #define System_Buffers_Binary_BinaryPrimitives_ReverseEndiannessusizeusize __builtin_bswap64
-#ifndef __SDCC
+#if !(defined(__SDCC) || defined(__LCC__))
 static inline int32_t System_Numerics_BitOperations_TrailingZeroCountusizei32(uintptr_t val) {if (val == 0) return sizeof(uintptr_t) * 8; return (int32_t) __builtin_ctzl((uint64_t)val);}
 static inline int32_t System_Numerics_BitOperations_TrailingZeroCountu32i32(uint32_t val) {if (val == 0) return sizeof(uint32_t) * 8; return (int32_t) __builtin_ctzl((uint32_t)val);}
 static inline int32_t System_Numerics_BitOperations_TrailingZeroCounti32i32(int32_t val) {if (val == 0) return sizeof(int32_t) * 8; return (int32_t) __builtin_ctzl((uint32_t)val);}
@@ -341,6 +373,7 @@ static inline int32_t System_Numerics_BitOperations_LeadingZeroCountusizei32(uin
 #define System_Numerics_BitOperations_PopCountu64i32(val) __builtin_popcountl((uint64_t)val)
 #define System_UInt128_PopCountu128u128(val) __builtin_popcountl((uint64_t)val)
 
+#define System_Console_WriteLinev() printf("\n")
 #define System_Console_WriteLinestv(msg) printf("%s\n", msg)
 #define System_Console_WriteLinef64v(val) printf("%f\n", val)
 
@@ -484,8 +517,12 @@ double fabsf64(double val);
 #define System_Double_Sinf64f64 sin
 #define System_Double_Absf64f64 fabsf64
 #define System_Single_Absf32f32 fabsf32
+#define System_Single_Sqrtf32f32(x) (float)sqrt((double)x)
 #define System_MathF_Sqrtf32f32(x) (float)sqrt((double)x)
+#define System_Double_Sqrtf64f64 sqrt
 #define System_MathF_Sqrtf64f64 sqrt
+#define System_Single_Floorf32f32(x) (float)floor((double)x)
+#define System_Single_Ceilingf32f32(x) (float)ceil((double)x)
 #define System_MathF_Roundf32f32(x) (float)round((double)x)
 #define System_Single_Powf32f32f32(a, b) (float)pow(a, b)
 #define System_Single_Powf64f64f64 pow
@@ -555,11 +592,14 @@ BUILTIN_UNSUPORTED(System_Double_Log2f64f64,double,(double input))
 #define System_Math_Floorf64f64(input) floor(input)
 #define System_Math_Sqrtf64f64(input) sqrt(input)
 #define System_Math_Ceilingf64f64(input) ceil(input)
+#define System_Double_Ceilingf64f64(input) ceil(input)
 #define System_MathF_Ceilingf32f32(input) (float)ceil((double)input)
 #define System_Math_Floorf64f64(input) floor(input)
+#define System_Double_Floorf64f64(input) floor(input)
 #define System_MathF_Floorf32f32(input) (float)floor((double)input)
 #define System_Math_Truncatef64f64(input) trunc(input)
-
+#define System_Double_Truncatef64f64(input) trunc(input)
+#define System_Single_Truncatef32f32(input) (float)trunc((double)input)
 static inline uint32_t System_Threading_Interlocked_CompareExchangeru32u32u32u32(uint32_t *addr, uint32_t value, uint32_t comparand)
 {
     uint32_t res = 0;
@@ -612,7 +652,7 @@ static inline intptr_t System_Threading_Interlocked_CompareExchangerisizeisizeis
         return comparand;
     }
 }
-#ifndef __SDCC
+#if !(defined(__SDCC) || defined(__LCC__))
 static inline uint32_t System_Threading_Interlocked_Exchangeru32u32u32(uint32_t *addr, uint32_t val)
 {
     uint32_t ret;
@@ -704,7 +744,7 @@ static inline uint8_t System_Byte_RotateLeftu8i32u8(uint8_t val, int32_t amount)
       if(amount == 0) return val;
     return ((val << amount) | (val >> ( (sizeof(uint8_t)*8) - amount)));
 }
-#ifndef __SDCC
+#if !(defined(__SDCC) || defined(__LCC__))
 static inline unsigned __int128 System_UInt128_LeadingZeroCountu128u128(unsigned __int128 val){ if (val == 0) return 128; return __builtin_clzl(val); }
 #endif
 static inline uint32_t System_Math_Minu32u32u32(uint32_t lhs, uint32_t rhs)

cilly/src/v2/c_exporter/mod.rs

@@ -648,6 +648,9 @@ impl CExporter {
         Ok(match root {
             CILRoot::StLoc(id, node_idx) => {
                 let name = local_name(locals, asm, id);
+                if let CILNode::LocAllocAlgined { tpe, align } = asm[node_idx]{
+                    return Ok(format!("loc_alloc_aligned({name},{tpe},{align},t{hash})",tpe = c_tpe(asm[tpe],asm),hash = encode(asm.alloc_root(root).as_bimap_index().get() as u64)));
+                }
                 return Ok(format!("{name} = {node};", node = Self::node_to_string(asm[node_idx].clone(), asm, locals, inputs, sig)?,));
             },
             CILRoot::StArg(arg, node_idx) =>match inputs[arg as usize].1 {
@@ -940,6 +943,21 @@ impl CExporter {
             )?;
         }
         let blocks = def.blocks(asm).unwrap().to_vec();
+           // Prepare allocas, if needed.
+           for root in blocks[0].roots(){
+                let CILRoot::StLoc(loc,node ) = asm[*root] else{
+                    continue;
+                };
+                let CILNode::LocAllocAlgined { tpe, align } = asm[node] else {
+                    continue;
+                };
+                writeln!(
+                    method_defs,
+                    "register_alloca_aligned(t{hash}, {tpe},{align});",
+                    hash = encode(root.as_bimap_index().get() as u64),
+                    tpe = c_tpe(asm[tpe], asm),
+                )?;
+           }
         let mut block_iter = blocks.iter().peekable();
         while let Some(block) = block_iter.next() {
             writeln!(method_defs, "bb{}:", block.block_id())?;
@@ -1175,7 +1193,7 @@ impl CExporter {
 
         let mut cmd = std::process::Command::new(Self::c_compiler());
         if is_main {
-            cmd.args(["-D", "MAIN_FILE"]);
+            cmd.args(["-DMAIN_FILE"]);
         }
 
         cmd.arg("-fPIC");
@@ -1212,11 +1230,18 @@ impl CExporter {
         let stderr = String::from_utf8_lossy(&out.stderr);
         if !*LINKER_RECOVER {
             assert!(
-                !(stderr.contains("error:") || stderr.contains("fatal")),
+                !(stderr.contains("error:")
+                    || stderr.contains("fatal")
+                    || stderr.contains("failed")),
                 "stdout:{} stderr:{} cmd:{cmd:?}",
                 stdout,
                 String::from_utf8_lossy(&out.stderr)
             );
+            println!(
+                "linker success. stdout:{} stderr:{} cmd:{cmd:?}",
+                stdout,
+                String::from_utf8_lossy(&out.stderr)
+            );
         }
 
         Ok(())

cilly/src/v2/method.rs

@@ -392,7 +392,7 @@ impl MethodDef {
         }
         let mut preamble = vec![];
         for (local_id, (_, tpe_idx, align)) in to_map {
-            if align <= 8 {
+            if align <= asm.guaranted_align() as u64 {
                 // Aligement guanrateed by .NET, skip.
                 continue;
             }

src/aggregate.rs

@@ -251,7 +251,9 @@ pub fn handle_aggregate<'tcx>(
                 (place_get(target_location, ctx)),
             )
         }
-        AggregateKind::CoroutineClosure(..) => todo!("Unsuported aggregate kind {aggregate_kind:?}"),
+        AggregateKind::CoroutineClosure(..) => {
+            todo!("Unsuported aggregate kind {aggregate_kind:?}")
+        }
     }
 }
 /// Builds an Algebraic Data Type (struct,enum,union) at location `target_location`, with fields set using ops in `fields`.

src/assembly.rs

@@ -695,7 +695,7 @@ pub fn add_allocation(alloc_id: u64, asm: &mut cilly::v2::Assembly, tcx: TyCtxt<
     let byte_hash = calculate_hash(&bytes);
     match (align, bytes.len()) {
         // Assumes this constant is not a pointer.
-        (0..=1, 1) | (0..=2, 1..=2) | (0..=4, 1..=4) | (0..=8, 1..=16) => {
+        (0..=1, len @ 1) | (0..=2, len @ 1..=2) | (0..=4, len @ 1..=4) | (0..=8, len @ 1..=16) if len <= asm.max_static_size()=> {
             let alloc_name: IString = if let Some(krate) = krate {
                 format!(
                     "s_{}_{}_{}_{thread_local}_{}",
@@ -715,7 +715,10 @@ pub fn add_allocation(alloc_id: u64, asm: &mut cilly::v2::Assembly, tcx: TyCtxt<
                 .into()
             };
             let name = asm.alloc_string(alloc_name.clone());
-            let tpe: Int = Int::from_size_sign(u8::try_from(bytes.len()).unwrap().next_power_of_two(), false);
+            let tpe: Int = Int::from_size_sign(
+                u8::try_from(bytes.len()).unwrap().next_power_of_two(),
+                false,
+            );
             let field_desc = StaticFieldDesc::new(*asm.main_module(), name, cilly::Type::Int(tpe));
             // Currently, all static fields are in one module. Consider spliting them up.
             let main_module = asm.class_mut(main_module_id);

src/binop/checked/mod.rs

@@ -506,12 +506,7 @@ pub fn add_unsigned<'tcx>(
 
     result_tuple(
         tpe,
-        super::cmp::lt_unchecked(
-            ty,
-            res.clone(),
-            ops_a.clone(),
-            ctx,
-        ),
+        super::cmp::lt_unchecked(ty, res.clone(), ops_a.clone(), ctx),
         res,
         ctx,
     )

src/constant.rs

@@ -118,9 +118,6 @@ pub mod native_pastrough;
 mod codegen_error;
 /// Test harnesses.
 pub mod compile_test;
-/// Code handling loading constant values in CIL.
-mod constant;
-
 /// Implementation of compiletime features neccessary for interop.
 mod comptime;
 /// Signature of a function (inputs)->output

src/lib.rs

@@ -11,7 +11,6 @@ use rustc_middle::ty::Ty;
 
 use rustc_codegen_clr_ctx::MethodCompileCtx;
 
-
 #[derive(Clone, Debug)]
 pub(crate) enum FieldOffsetIterator {
     Explicit { offsets: Box<[u32]>, index: usize },
@@ -85,7 +84,6 @@ impl FieldOffsetIterator {
             }
         }
     }
-
 }
 /// Takes layout of an enum as input, and returns the type of its tag(Void if no tag) and the size of the tag(0 if no tag).
 pub fn enum_tag_info(r#enum: Layout<'_>, asm: &mut Assembly) -> (Type, u32) {