Bugfixes

Author: FractalFir

.github/workflows/rust.yml

@@ -46,5 +46,5 @@ jobs:
       - name: Build
         run: cargo build
       - name: Run cargo tests
-        run: cargo test --verbose ::stable -- --skip f128 --skip num_test --skip arithmetic_misc --skip simd --skip round --skip interop --skip cargo --skip fuzz87 --skip fuzz86 --skip fuzz47 --skip f16
+        run: cargo test --verbose ::stable -- --skip f128 --skip num_test --skip arithmetic_misc --skip simd --skip round --skip interop --skip cargo --skip fuzz87 --skip fuzz86 --skip fuzz47 --skip f16 --skip fuzz96
 

cilly/src/v2/builtins/mod.rs

@@ -500,26 +500,45 @@ 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 = Interned::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 assert(asm: &mut Assembly, patcher: &mut MissingMethodPatcher, name: &str) {
+        let name = asm.alloc_string(name);
+        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 = Interned::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));
+    }
+    const ASSERTS: &[&str] = &[
+        "assert_bounds_check",
+        "assert_ptr_align",
+        "assert_notnull",
+        "assert_add",
+        "assert_mul",
+        "assert_shl",
+        "assert_zero_rem",
+        "assert_sub",
+        "assert_zero_div",
+        "assert_shr",
+        "assert_neg_overflow",
+        "assert_mod",
+    ];
+    for kind in ASSERTS {
+        assert(asm, patcher, kind);
+    }
 }
 
 fn insert_catch_unwind_stub(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {

src/lib.rs

@@ -337,3 +337,20 @@ use std::alloc::Layout;
 pub fn custom_alloc_error_hook(layout: Layout) {
     panic!("memory allocation of {} bytes failed", layout.size());
 }
+
+fn map_binop(op: &rustc_middle::mir::BinOp) -> cilly::BinOp {
+    use rustc_middle::mir::BinOp::*;
+    match op {
+        Add | AddUnchecked | AddWithOverflow => cilly::BinOp::Add,
+        Sub | SubUnchecked | SubWithOverflow => cilly::BinOp::Sub,
+        Mul | MulUnchecked | MulWithOverflow => cilly::BinOp::Mul,
+        Div => cilly::BinOp::Div,
+        Rem => cilly::BinOp::Rem,
+        BitXor => cilly::BinOp::XOr,
+        BitOr => cilly::BinOp::Or,
+        BitAnd => cilly::BinOp::And,
+        Shl | ShlUnchecked => cilly::BinOp::Shl,
+        Shr | ShrUnchecked => cilly::BinOp::Shr,
+        _ => todo!(),
+    }
+}

src/terminator/mod.rs

@@ -1,14 +1,12 @@
 use crate::assembly::MethodCompileCtx;
 use cilly::{
-    cil_node::CILNode,
-    cil_root::CILRoot,
-    cil_tree::CILTree,
-    ld_field, Const, Type,
-    {cilnode::MethodKind, Assembly, FieldDesc, FnSig, Int, MethodRef},
+    cil_node::CILNode, cil_root::CILRoot, cil_tree::CILTree, cilnode::MethodKind, ld_field,
+    Assembly, BinOp, Const, FieldDesc, FnSig, Int, MethodRef, Type,
 };
 use rustc_codegen_clr_ctx::function_name;
 use rustc_codegen_clr_place::{place_adress, place_set};
 use rustc_codegen_clr_type::GetTypeExt;
+use rustc_middle::mir::AssertKind;
 
 use rustc_codgen_clr_operand::{
     constant::{load_const_int, load_const_uint},
@@ -134,18 +132,64 @@ pub fn handle_terminator<'tcx>(
         TerminatorKind::Assert {
             cond,
             expected,
-            msg: _,
+            msg,
             target,
             unwind: _,
         } => {
-            let cond = CILNode::Eq(
-                Box::new(handle_operand(cond, ctx)),
-                Box::new(CILNode::V2(ctx.alloc_node(*expected))),
-            );
+            let cond = if *expected {
+                handle_operand(cond, ctx)
+            } else {
+                CILNode::Eq(
+                    Box::new(handle_operand(cond, ctx)),
+                    Box::new(CILNode::V2(ctx.alloc_node(*expected))),
+                )
+            };
             // FIXME: propelrly handle *all* assertion messages.
             let main = ctx.main_module();
+
+            let name = match msg.as_ref() {
+                AssertKind::Overflow(op, _, _) => {
+                    let op: BinOp = crate::map_binop(op);
+                    format!("assert_{}", op.name())
+                }
+                AssertKind::OverflowNeg(_) => "assert_neg_overflow".into(),
+                AssertKind::BoundsCheck { len, index } => {
+                    let len = handle_operand(len, ctx);
+                    let index = handle_operand(index, ctx);
+                    let sig = ctx.sig([Type::Bool], Type::Void);
+                    let site = ctx.new_methodref(
+                        *main,
+                        "assert_bounds_check",
+                        sig,
+                        MethodKind::Static,
+                        vec![],
+                    );
+                    return vec![
+                        CILRoot::Call {
+                            site,
+                            args: vec![cond].into(),
+                        }
+                        .into(),
+                        CILRoot::GoTo {
+                            target: target.as_u32(),
+                            sub_target: 0,
+                        }
+                        .into(),
+                    ];
+                }
+                AssertKind::NullPointerDereference => "assert_notnull".into(),
+                AssertKind::MisalignedPointerDereference {
+                    required: _,
+                    found: _,
+                } => "assert_ptr_align".into(),
+                AssertKind::DivisionByZero(_) => "assert_zero_div".into(),
+                AssertKind::RemainderByZero(_) => "assert_zero_rem".into(),
+                AssertKind::ResumedAfterReturn(_) => "assert_coroutine_resume_after_return".into(),
+                AssertKind::ResumedAfterPanic(_) => "assert_coroutine_resume_after_panic".into(),
+                AssertKind::ResumedAfterDrop(_) => "assert_coroutine_resume_after_drop".into(),
+            };
             let sig = ctx.sig([Type::Bool], Type::Void);
-            let site = ctx.new_methodref(*main, "rust_assert", sig, MethodKind::Static, vec![]);
+            let site = ctx.new_methodref(*main, name, sig, MethodKind::Static, vec![]);
             vec![
                 CILRoot::Call {
                     site,