Added support for TerminatorKind::Assert

Author: FractalFir

bin/c_success_coretests.txt

@@ -131,7 +131,6 @@ cell::refcell_unsized
 cell::smoketest_cell
 cell::smoketest_unsafe_cell
 cell::unsafe_cell_raw_get
-cell::unsafe_cell_unsized
 char::ed_iterator_specializations
 char::eu_iterator_specializations
 char::test_convert
@@ -666,7 +665,6 @@ num::bignum::test_mul_digits
 num::bignum::test_mul_pow2
 num::bignum::test_mul_pow2_overflow_1
 num::bignum::test_mul_pow5
-num::bignum::test_mul_pow5_overflow_1
 num::bignum::test_mul_small
 num::bignum::test_ord
 num::bignum::test_sub
@@ -741,7 +739,6 @@ num::i128::test_le
 num::i128::test_leading_trailing_ones
 num::i128::test_midpoint
 num::i128::test_next_multiple_of
-num::i128::test_num
 num::i128::test_overflows
 num::i128::test_rem_euclid
 num::i128::test_rotate
@@ -902,7 +899,6 @@ 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
 num::int_log::ilog10_u16
 num::int_log::ilog10_u32
 num::int_log::ilog10_u64
@@ -946,7 +942,6 @@ num::ops::test_bitxor_assign_defined
 num::ops::test_bitxor_defined
 num::ops::test_div_assign_defined
 num::ops::test_div_defined
-num::ops::test_mul_assign_defined
 num::ops::test_mul_defined
 num::ops::test_neg_defined
 num::ops::test_not_defined_bool
@@ -1166,10 +1161,8 @@ num::u128::test_isolate_most_significant_one
 num::u128::test_isqrt
 num::u128::test_le
 num::u128::test_leading_trailing_ones
-num::u128::test_lots_of_isqrt
 num::u128::test_midpoint
 num::u128::test_next_multiple_of
-num::u128::test_num
 num::u128::test_overflows
 num::u128::test_reverse_bits
 num::u128::test_rotate
@@ -1463,7 +1456,6 @@ 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/bin/linker/main.rs

@@ -436,6 +436,7 @@ fn main() {
     cilly::builtins::insert_bounds_check(&mut final_assembly, &mut overrides);
     cilly::builtins::casts::insert_casts(&mut final_assembly, &mut overrides);
     cilly::builtins::insert_heap(&mut final_assembly, &mut overrides, *C_MODE);
+    cilly::builtins::rust_assert(&mut final_assembly, &mut overrides);
     cilly::builtins::int128::generate_int128_ops(&mut final_assembly, &mut overrides, *C_MODE);
     cilly::builtins::int128::i128_mul_ovf_check(&mut final_assembly, &mut overrides);
     cilly::builtins::int128::u128_mul_ovf_check(&mut final_assembly, &mut overrides);

cilly/src/v2/builtins/mod.rs

@@ -476,6 +476,29 @@ fn insert_pause(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
     };
     patcher.insert(name, Box::new(generator));
 }
+pub fn rust_assert(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
+    let name = asm.alloc_string("rust_assert");
+    let generator = move |_, asm: &mut Assembly| {
+        let ret = asm.alloc_root(CILRoot::VoidRet);
+        let assert = asm.alloc_node(CILNode::LdArg(0));
+        let assert = asm.alloc_root(CILRoot::Branch(Box::new((
+            1,
+            0,
+            Some(BranchCond::False(assert)),
+        ))));
+        let mref = MethodRefIdx::abort(asm);
+        let assert_failed = asm.alloc_root(CILRoot::call(mref, vec![]));
+        MethodImpl::MethodBody {
+            blocks: vec![
+                BasicBlock::new(vec![assert, ret], 0, None),
+                BasicBlock::new(vec![assert_failed, ret], 1, None),
+            ],
+            locals: vec![],
+        }
+    };
+    patcher.insert(name, Box::new(generator));
+}
+
 fn insert_catch_unwind_stub(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
     let name = asm.alloc_string("catch_unwind");
     let generator = move |_, asm: &mut Assembly| {

cilly/src/v2/c_exporter/c_header.h

@@ -376,11 +376,11 @@ static inline int32_t System_Numerics_BitOperations_LeadingZeroCountu64i32(uint6
 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_Numerics_BitOperations_PopCountusizei32(val) __builtin_popcountll((uint64_t)val)
+#define System_Numerics_BitOperations_PopCountu32i32(val) __builtin_popcountll((uint32_t)val)
+#define System_Numerics_BitOperations_PopCountu64i32(val) __builtin_popcountll((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)); 
+    return __builtin_popcountll((uint64_t)val) +  __builtin_popcountll((uint64_t)(val>>64)); 
 }
 
 #define System_Console_WriteLinev() printf("\n")

cilly/src/v2/cilnode.rs

@@ -26,18 +26,32 @@ impl IsPure {
 }
 #[derive(Hash, PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
 pub enum CILNode {
+    /// A constant IR value.
     Const(Box<Const>),
+    /// Binary operation performed on values `lhs` and `rhs`, of kind `op`.
     BinOp(NodeIdx, NodeIdx, BinOp),
+    /// A unary operation performed on value `val`, of kind `op`.
     UnOp(NodeIdx, UnOp),
+    /// Retrives the value of a local with a given index.
     LdLoc(u32),
+    /// Retrives a reference(not a pointer!) to a local with a given index.
+    /// See [crate::tpe::Type::Ref].
     LdLocA(u32),
+    /// Retrives the value of an argument with a given index.
     LdArg(u32),
+    /// Retrives a reference(not a pointer!) to an argument with a given index.
+    /// See [crate::tpe::Type::Ref].
     LdArgA(u32),
-    /// Method, args, pure
+    /// Calls `method` with, `args`, and a given `pure`-ness.
+    /// [`IsPure::PURE`] value marks a call as a pure, side-effect free call.
     Call(Box<(MethodRefIdx, Box<[NodeIdx]>, IsPure)>),
+    /// A cast to an intiger type.
     IntCast {
+        /// The input value.
         input: NodeIdx,
+        /// The resulting type
         target: Int,
+        /// Is this a signed or zero extension?
         extend: ExtendKind,
     },
     FloatCast {

cilly/src/v2/cst.rs

@@ -6,27 +6,47 @@ use super::{
 };
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug, Hash, Serialize, Deserialize)]
+/// A constant cillyIR value.
 pub enum Const {
+    /// Constant i8 value.
     I8(i8),
+    /// Constant i16 value.
     I16(i16),
+    /// Constant i32 value.
     I32(i32),
+    /// Constant i64 value.
     I64(i64),
+    /// Constant i128 value.
     I128(i128),
+    /// Constant isize value.
     ISize(i64),
+    /// Constant u8 value.
     U8(u8),
+    /// Constant u16 value.
     U16(u16),
+    /// Constant u32 value.
     U32(u32),
+    /// Constant u64 value.
     U64(u64),
+    /// Constant u128 value.
     U128(u128),
+    /// Constant usize value.
     USize(u64),
+    /// A reference to an immutable, platform-specific representation of a string.
+    /// There is no guarrantees about the encoding of this type.
     PlatformString(StringIdx),
+    /// A boolean value
     Bool(bool),
+    /// A representation of a single-precision floating-point value. No guarateess are given about the exact bitpattern of NaNs.  
     F32(HashableF32),
+    /// A representation of a double-precision floating-point value. No guarateess are given about the exact bitpattern of NaNs.
     F64(HashableF64),
+    /// A "null" reference to a platform-specifc managed object of type `class`.
     Null(ClassRefIdx),
 }
 impl Const {
-    pub(crate) fn get_type(&self) -> Type {
+    /// Retrives the type of this value.
+    pub fn get_type(&self) -> Type {
         match self {
             Const::I8(_) => Type::Int(Int::I8),
             Const::I16(_) => Type::Int(Int::I16),
@@ -47,8 +67,8 @@ impl Const {
             Const::Null(tpe) => Type::ClassRef(*tpe),
         }
     }
-
-    pub(crate) fn is_zero(&self) -> bool {
+    /// Checks if the value is zero.
+    pub fn is_zero(&self) -> bool {
         match self {
             Const::I8(val) => *val == 0,
             Const::I16(val) => *val == 0,
@@ -69,7 +89,8 @@ impl Const {
             Const::Null(_) => true,
         }
     }
-    pub(crate) fn is_one(&self) -> bool {
+    /// Checks if the value is exactly one.
+    pub fn is_one(&self) -> bool {
         match self {
             Const::I8(val) => *val == 1,
             Const::I16(val) => *val == 1,
@@ -85,8 +106,8 @@ impl Const {
             Const::USize(val) => *val == 1,
             Const::PlatformString(_) => false,
             Const::Bool(_) => false,
-            Const::F32(val) => **val == 1.1,
-            Const::F64(val) => **val == 1.1,
+            Const::F32(val) => **val == 1.0,
+            Const::F64(val) => **val == 1.0,
             Const::Null(_) => true,
         }
     }

cilly/src/v2/method.rs

@@ -742,7 +742,6 @@ impl MethodImpl {
         let args = sig
             .inputs()
             .iter()
-          
             .enumerate()
             .map(|(idx, _)| asm.alloc_node(CILNode::LdArg(idx.try_into().unwrap())))
             .collect();
@@ -787,6 +786,12 @@ impl MethodRefIdx {
     pub unsafe fn from_raw(raw: BiMapIndex) -> Self {
         Self(raw)
     }
+
+    pub fn abort(asm: &mut Assembly) -> MethodRefIdx {
+        let main = asm.main_module();
+        let sig = asm.sig([], Type::Void);
+        asm.new_methodref(*main, "abort", sig, MethodKind::Static, vec![])
+    }
 }
 #[test]
 fn locals() {

rustc_codegen_clr_place/src/adress.rs

@@ -8,7 +8,9 @@ use cilly::{
 };
 use rustc_codegen_clr_ctx::MethodCompileCtx;
 use rustc_codegen_clr_type::{
-    adt::{enum_field_descriptor, field_descrptor, FieldOffsetIterator}, r#type::{fat_ptr_to, get_type}, GetTypeExt
+    GetTypeExt,
+    adt::{FieldOffsetIterator, enum_field_descriptor, field_descrptor},
+    r#type::{fat_ptr_to, get_type},
 };
 use rustc_middle::{
     mir::PlaceElem,
@@ -226,10 +228,13 @@ pub fn place_elem_adress<'tcx>(
             }
         }
         PlaceElem::Subslice { from, to, from_end } => {
-            let elem_type = curr_type.as_ty().expect("Can't index into an enum!").sequence_element_type(ctx.tcx());
-            let elem_type = get_type(elem_type,ctx);
+            let elem_type = curr_type
+                .as_ty()
+                .expect("Can't index into an enum!")
+                .sequence_element_type(ctx.tcx());
+            let elem_type = get_type(elem_type, ctx);
             let curr_type = fat_ptr_to(curr_type.as_ty().expect("Can't index into an enum!"), ctx);
-            
+
             if *from_end {
                 //assert!(from >= to, "from_end:{from_end} from:{from} to:{to}");
                 let metadata_name = ctx.alloc_string(cilly::METADATA);
@@ -248,8 +253,13 @@ pub fn place_elem_adress<'tcx>(
                     Box::new(CILNode::V2(ctx.alloc_node(Const::USize(*to + from)))),
                 );
 
-                let data_ptr = ld_field!(addr_calc, ptr_field)
-                    + CILNode::V2(ctx.alloc_node(Const::USize(*from))) * conv_usize!(CILNode::V2(ctx.size_of(elem_type).into_idx(ctx)));
+                let data_ptr = if elem_type != Type::Void {
+                    ld_field!(addr_calc, ptr_field)
+                        + CILNode::V2(ctx.alloc_node(Const::USize(*from)))
+                            * conv_usize!(CILNode::V2(ctx.size_of(elem_type).into_idx(ctx)))
+                } else {
+                    ld_field!(addr_calc, ptr_field)
+                };
                 CILNode::create_slice(curr_type, ctx, metadata, data_ptr)
             } else {
                 let void_ptr = ctx.nptr(Type::Void);
@@ -258,7 +268,8 @@ pub fn place_elem_adress<'tcx>(
                 let ptr_field = ctx.alloc_field(FieldDesc::new(curr_type, data_ptr, void_ptr));
                 let metadata = CILNode::V2(ctx.alloc_node(Const::USize(to - from)));
                 let data_ptr = ld_field!(addr_calc, ptr_field)
-                    + CILNode::V2(ctx.alloc_node(Const::USize(*from))) * conv_usize!(CILNode::V2(ctx.size_of(elem_type).into_idx(ctx)));
+                    + CILNode::V2(ctx.alloc_node(Const::USize(*from)))
+                        * conv_usize!(CILNode::V2(ctx.size_of(elem_type).into_idx(ctx)));
 
                 CILNode::create_slice(curr_type, ctx, metadata, data_ptr)
             }

rustc_codegen_clr_type/src/adt.rs

@@ -4,9 +4,9 @@ use cilly::{
 };
 use rustc_abi::{FieldIdx, FieldsShape, Layout, LayoutData, VariantIdx, Variants};
 use rustc_codegen_clr_ctx::MethodCompileCtx;
+use rustc_middle::span_bug;
 use rustc_middle::ty::List;
 use rustc_middle::ty::{AdtDef, GenericArg, Ty, TyKind};
-
 pub fn enum_variant_offsets(_: AdtDef, layout: Layout, vidix: VariantIdx) -> FieldOffsetIterator {
     FieldOffsetIterator::fields(get_variant_at_index(vidix, (*layout.0).clone()))
 }
@@ -215,14 +215,20 @@ pub fn field_descrptor<'tcx>(
             field_type,
         ));
     } else if let TyKind::Coroutine(_, args) = owner_ty.kind() {
-        let coroutine = args.as_coroutine();
-        let field_type = coroutine
-            .upvar_tys()
+        let coroutine = args.as_coroutine().witness();
+        let TyKind::CoroutineWitness(_, fields) = coroutine.kind() else {
+            panic!("corutine witness is not CoroutineWitness.");
+        };
+        let field_type = fields
             .iter()
             .nth(field_idx as usize)
             .expect("Could not find coroutine fields!");
         let field_type = ctx.monomorphize(field_type);
-        let field_type = ctx.type_from_cache(field_type);
+        let field_type = ctx.type_from_cache(
+            field_type
+                .as_type()
+                .expect("Non type args in coroutine witness."),
+        );
         let owner_ty = ctx.monomorphize(owner_ty);
         let owner_type = ctx.type_from_cache(owner_ty);
         let field_name = ctx.alloc_string(format!("f_{field_idx}"));

rustc_codgen_clr_operand/src/constant.rs

@@ -13,7 +13,7 @@ use cilly::{
 use rustc_codegen_clr_call::CallInfo;
 use rustc_codegen_clr_ctx::MethodCompileCtx;
 use rustc_codegen_clr_place::deref_op;
-use rustc_codegen_clr_type::GetTypeExt;
+use rustc_codegen_clr_type::{GetTypeExt, utilis::is_fat_ptr};
 use rustc_middle::ty::ExistentialTraitRef;
 use rustc_middle::{
     mir::{
@@ -245,10 +245,20 @@ fn load_const_scalar<'tcx>(
         TyKind::Uint(uint_type) => CILNode::V2(load_const_uint(scalar_u128, *uint_type, ctx)),
         TyKind::Float(ftype) => load_const_float(scalar_u128, *ftype, ctx),
         TyKind::Bool => CILNode::V2(ctx.alloc_node(scalar_u128 != 0)),
-        TyKind::RawPtr(_, _) => CILNode::V2(ctx.alloc_node(Const::USize(
-            u64::try_from(scalar_u128).expect("pointers must be smaller than 2^64"),
-        )))
-        .cast_ptr(scalar_type),
+        TyKind::RawPtr(..) | TyKind::Ref(..) => {
+            if is_fat_ptr(scalar_ty, ctx.tcx(), ctx.instance()) {
+                CILNode::V2(ctx.alloc_node(scalar_u128)).transmute_on_stack(
+                    Type::Int(Int::U128),
+                    scalar_type,
+                    ctx,
+                )
+            } else {
+                CILNode::V2(ctx.alloc_node(Const::USize(
+                    u64::try_from(scalar_u128).expect("pointers must be smaller than 2^64"),
+                )))
+                .cast_ptr(scalar_type)
+            }
+        }
         TyKind::Tuple(elements) => {
             if elements.is_empty() {
                 let scalar_ptr = ctx.nptr(scalar_type);

src/compile_test.rs

@@ -806,6 +806,7 @@ run_test! {intrinsics,wrapping_ops,stable}
 run_test! {iter,fold,stable}
 run_test! {statics,thread_local,stable}
 run_test! {std,arg_test,stable}
+run_test! {std,getopt,stable}
 run_test! {std,const_error,stable}
 run_test! {std,cell_test,unstable}
 run_test! {std,cstr,unstable}

src/terminator/intrinsics/mod.rs

@@ -1100,7 +1100,6 @@ fn intrinsic_slow<'tcx>(
                 "intrinsic {} must be overridden by rustc_codgen_clr, but isn't",
                 intrinsic.name,
             );
-            todo!("ERROR: span bug did not diverge.");
         }
         super::call::call_inner(
             Instance::new(call_instance.def_id(), call_instance.args)