Misc fixes + tests

Author: FractalFir

bin/c_success_coretests.txt

@@ -628,6 +628,8 @@ net::socket_addr::set_scope_id
 net::socket_addr::socket_v4_to_str
 net::socket_addr::socket_v6_to_str
 nonzero::nonzero_const
+nonzero::nonzero_leading_zeros
+nonzero::nonzero_trailing_zeros
 nonzero::test_create_nonzero_instance
 nonzero::test_from_nonzero
 nonzero::test_from_signed_nonzero
@@ -645,6 +647,8 @@ nonzero::test_nonzero_bitor_assign
 nonzero::test_nonzero_fmt
 nonzero::test_nonzero_from_int_on_err
 nonzero::test_nonzero_from_int_on_success
+nonzero::test_nonzero_isolate_least_significant_one
+nonzero::test_nonzero_isolate_most_significant_one
 nonzero::test_nonzero_uint_div
 nonzero::test_nonzero_uint_rem
 nonzero::test_signed_nonzero_neg
@@ -723,13 +727,16 @@ num::i128::test_borrowing_sub
 num::i128::test_carrying_add
 num::i128::test_checked_next_multiple_of
 num::i128::test_count_ones
+num::i128::test_count_zeros
 num::i128::test_div_ceil
 num::i128::test_div_floor
 num::i128::test_from_str
 num::i128::test_is_negative
 num::i128::test_is_positive
 num::i128::test_isolate_least_significant_one
+num::i128::test_isolate_most_significant_one
 num::i128::test_le
+num::i128::test_leading_trailing_ones
 num::i128::test_midpoint
 num::i128::test_next_multiple_of
 num::i128::test_num
@@ -887,6 +894,9 @@ num::ieee754::neg_infinity_to_str
 num::ieee754::preserve_signed_infinity
 num::ieee754::preserve_signed_zero
 num::ieee754::qnan_from_str
+num::int_log::checked_ilog
+num::int_log::checked_ilog10
+num::int_log::checked_ilog2
 num::int_log::ilog0_of_1_panic
 num::int_log::ilog10_of_0_panic
 num::int_log::ilog10_u128
@@ -897,6 +907,8 @@ num::int_log::ilog10_u8
 num::int_log::ilog1_of_1_panic
 num::int_log::ilog2_of_0_panic
 num::int_log::ilog3_of_0_panic
+num::int_sqrt::i128::isqrt
+num::int_sqrt::i128::isqrt_extended
 num::int_sqrt::i16::isqrt
 num::int_sqrt::i16::isqrt_extended
 num::int_sqrt::i32::isqrt
@@ -1137,12 +1149,15 @@ num::u128::test_borrowing_sub
 num::u128::test_carrying_add
 num::u128::test_checked_next_multiple_of
 num::u128::test_count_ones
+num::u128::test_count_zeros
 num::u128::test_div_ceil
 num::u128::test_div_floor
 num::u128::test_from_str
 num::u128::test_is_next_multiple_of
 num::u128::test_isolate_least_significant_one
+num::u128::test_isolate_most_significant_one
 num::u128::test_le
+num::u128::test_leading_trailing_ones
 num::u128::test_midpoint
 num::u128::test_next_multiple_of
 num::u128::test_num

cilly/src/bin/linker/main.rs

@@ -470,6 +470,7 @@ fn main() {
             "pthread_join",
             "pthread_setspecific",
             "ldexpf",
+            "ldexp",
         ] {
             externs.insert(fnc, LIBC.clone());
         }

cilly/src/v2/c_exporter/c_header.h

@@ -363,15 +363,25 @@ static inline int32_t System_Numerics_BitOperations_TrailingZeroCountusizei32(ui
 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);}
 static inline int32_t System_Numerics_BitOperations_TrailingZeroCountu64i32(uint64_t val) {if (val == 0) return sizeof(uint64_t) * 8; return (int32_t) __builtin_ctzl((uint64_t)val);}
-static inline int32_t System_UInt128_TrailingZeroCountu128u128(__uint128_t val) {if (val == 0) return sizeof(__uint128_t) * 8; return (int32_t) __builtin_ctzl((__uint128_t)val);}
+static inline int32_t System_UInt128_TrailingZeroCountu128u128(__uint128_t val) {
+    if (val == 0) return sizeof(__uint128_t) * 8; 
+    if (((uint64_t)val) == 0){
+        return (int32_t) System_Numerics_BitOperations_TrailingZeroCountu64i32((uint64_t)(val >> 64)) + 64;
+    }
+    else{
+        return (int32_t) System_Numerics_BitOperations_TrailingZeroCountu64i32((uint64_t)(val));
+    }
+}
 static inline int32_t System_Numerics_BitOperations_LeadingZeroCountu64i32(uint64_t val) { if (val == 0) return 64; return __builtin_clzl(val); }
 static inline int32_t System_Numerics_BitOperations_LeadingZeroCountusizei32(uintptr_t val) { if (val == 0) return sizeof(uintptr_t) * 8; return __builtin_clzl((uint64_t)val); }
 #endif
 
 #define System_Numerics_BitOperations_PopCountusizei32(val) __builtin_popcountl((uint64_t)val)
 #define System_Numerics_BitOperations_PopCountu32i32(val) __builtin_popcountl((uint32_t)val)
 #define System_Numerics_BitOperations_PopCountu64i32(val) __builtin_popcountl((uint64_t)val)
-#define System_UInt128_PopCountu128u128(val) __builtin_popcountl((uint64_t)val)
+static inline __uint128_t System_UInt128_PopCountu128u128(__uint128_t val) {
+    return __builtin_popcountl((uint64_t)val) +  __builtin_popcountl((uint64_t)(val>>64)); 
+}
 
 #define System_Console_WriteLinev() printf("\n")
 #define System_Console_WriteLinestv(msg) printf("%s\n", msg)
@@ -582,12 +592,24 @@ static inline double System_Double_Expf64f64(double input){
     return exp(input);
 }
 #endif 
-BUILTIN_UNSUPORTED(System_Double_Log10f64f64,double,(double input))
-BUILTIN_UNSUPORTED(System_Single_Logf32f32,float,(float input))
-BUILTIN_UNSUPORTED(System_Single_Log2f32f32,float,(float input))
-BUILTIN_UNSUPORTED(System_Single_Log10f32f32,float,(float input))
-BUILTIN_UNSUPORTED(System_Double_Logf64f64,double,(double input))
-BUILTIN_UNSUPORTED(System_Double_Log2f64f64,double,(double input))
+static inline float System_Single_Log2f32f32(float input){
+    return log2f(input);
+}
+static inline float System_Double_Log2f64f64(float input){
+    return log2(input);
+}
+static inline float System_Single_Log10f32f32(float input){
+    return log10f(input);
+}
+static inline float System_Double_Log10f64f64(float input){
+    return log10(input);
+}
+static inline float System_Single_Logf32f32(float input){
+    return logf(input);
+}
+static inline float System_Double_Logf64f64(float input){
+    return log(input);
+}
 #define System_Math_Roundf64f64(input) round(input)
 #define System_Math_Floorf64f64(input) floor(input)
 #define System_Math_Sqrtf64f64(input) sqrt(input)
@@ -748,7 +770,15 @@ static inline uint8_t System_Byte_RotateLeftu8i32u8(uint8_t val, int32_t amount)
     return ((val << amount) | (val >> ( (sizeof(uint8_t)*8) - amount)));
 }
 #if !(defined(__SDCC) || defined(__LCC__))
-static inline unsigned __int128 System_UInt128_LeadingZeroCountu128u128(unsigned __int128 val){ if (val == 0) return 128; return __builtin_clzl(val); }
+static inline unsigned __int128 System_UInt128_LeadingZeroCountu128u128(__uint128_t val) {
+    if (val == 0) return sizeof(__uint128_t) * 8; 
+    if ((val>>64) == 0){
+        return (unsigned __int128) System_Numerics_BitOperations_LeadingZeroCountu64i32((uint64_t)(val)) + 64;
+    }
+    else{
+        return (unsigned __int128) System_Numerics_BitOperations_LeadingZeroCountu64i32((uint64_t)(val >> 64));
+    }
+}
 #endif
 static inline uint32_t System_Math_Minu32u32u32(uint32_t lhs, uint32_t rhs)
 {

rustc_codegen_clr_place/src/body.rs

@@ -140,6 +140,7 @@ fn body_field<'a>(
                 },
             )
         }
+        
     }
 }
 pub fn place_elem_body_index<'tcx>(
@@ -255,6 +256,13 @@ pub fn place_elem_body<'tcx>(
             parrent_node,
             *index,
         ),
+        PlaceElem::Subtype(tpe) => {
+            if body_ty_is_by_adress(curr_type.as_ty().unwrap(), ctx) {
+                (PlaceTy::Ty(*tpe),super::deref_op((*tpe).into(), ctx, parrent_node))
+            } else {
+                (PlaceTy::Ty(*tpe),parrent_node)
+            }
+        }
         PlaceElem::ConstantIndex {
             offset,
             min_length: _,

rustc_codegen_clr_place/src/lib.rs

@@ -118,7 +118,7 @@ pub fn deref_op<'tcx>(
             | TyKind::Tuple(_)
             | TyKind::Array(_, _)
             | TyKind::FnPtr(_, _)
-            | TyKind::Closure(_, _) => {
+            | TyKind::Closure(_, _) | TyKind::Coroutine(_, _)=> {
                 let derefed_type = ctx.type_from_cache(derefed_type);
 
                 CILNode::LdObj {
@@ -154,7 +154,7 @@ pub fn deref_op<'tcx>(
                     }
                 }
             }
-
+            
             _ => todo!("TODO: can't deref type {derefed_type:?} yet"),
         }
     } else {

src/compile_test.rs

@@ -757,6 +757,7 @@ run_test! {alloc,abox,stable}
 run_test! {alloc,raw_vec,stable}
 run_test! {alloc,slice_to_owned,stable}
 run_test! {arthm,add,stable}
+run_test! {arthm,ctlz,stable}
 run_test! {arthm,ptr,stable}
 run_test! {arthm,cmp,stable}
 run_test! {arthm,greater_than,stable}
@@ -819,6 +820,8 @@ run_test! {std,tlocal_key_test,stable}
 run_test! {std,uninit_fill,stable}
 
 run_test! {core,ascii_align,stable}
+run_test! {core,floatfmt,unstable}
+run_test! {core,flt2dec,unstable}
 run_test! {core,from_raw_parts,stable}
 run_test! {core,tuple_ord,stable}
 run_test! {core,zst_iter,stable}

src/utilis/adt.rs

@@ -329,7 +329,7 @@ pub fn get_discr<'tcx>(
                     Type::Int(Int::I128) => {
                         let mref = MethodRef::new(
                             main_module,
-                            ctx.alloc_string("in128_eq"),
+                            ctx.alloc_string("eq_i128"),
                             ctx.sig([Type::Int(Int::I128), Type::Int(Int::I128)], Type::Bool),
                             MethodKind::Static,
                             vec![].into(),

test/arthm/add.rs

@@ -7,9 +7,6 @@
 )]
 #![allow(internal_features, incomplete_features, unused_variables, dead_code)]
 #[allow(dead_code)]
-struct Test<T> {
-    data: T,
-}
 include!("../common.rs");
 #[inline(never)]
 #[no_mangle]

test/arthm/ctlz.rs

@@ -0,0 +1,34 @@
+#![feature(
+    lang_items,
+    adt_const_params,
+    associated_type_defaults,
+    core_intrinsics,
+    unsized_const_params
+)]
+#![allow(internal_features, incomplete_features, unused_variables, dead_code)]
+#[allow(dead_code)]
+include!("../common.rs");
+fn main() {
+    const A: u128 = 0b0101_1111_u128;
+    test_eq!(A.trailing_ones(), 5);
+    unsafe{printf(c"%u\n".as_ptr(),(!A).leading_ones() as u32)};
+    test_eq!((!A).leading_ones(), u128::BITS - 7);
+
+    test_eq!(A.reverse_bits().leading_ones(), 5);
+
+    test_eq!((!0_u128).leading_ones(), u128::BITS);
+    test_eq!((!0_u128).trailing_ones(), u128::BITS);
+
+    test_eq!(((!0_u128) << 1).trailing_ones(), 0);
+    test_eq!(((!0_u128) >> 1).leading_ones(), 0);
+
+    test_eq!(((!0_u128) << 1).leading_ones(), u128::BITS - 1);
+    test_eq!(((!0_u128) >> 1).trailing_ones(), u128::BITS - 1);
+
+    test_eq!(0_u128.leading_ones(), 0);
+    test_eq!(0_u128.trailing_ones(), 0);
+
+    const X: u128 = 0b0010_1100_u128;
+    test_eq!(X.leading_ones(), 0);
+    test_eq!(X.trailing_ones(), 0);
+}