projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* jit.c (MAKE_SPILLED_BI_ALU): remove unnecessary assertions
[mono.git] / mono / jit / x86.brg
diff --git a/mono/jit/x86.brg b/mono/jit/x86.brg
index b378bd7891f013e56fd9fbc1d5f2c32ff67a45f8..6af03abc804c28a766d14a91a818d4ab4425a250 100644 (file)
--- a/mono/jit/x86.brg
+++ b/mono/jit/x86.brg
@@ -116,7 +116,7 @@ get_mono_object_isinst (void);
 //#define DEBUG
 
 #define REAL_PRINT_REG(text,reg) \
-g_assert (reg >= 0); \
+mono_assert (reg >= 0); \
 x86_push_reg (s->code, X86_EAX); \
 x86_push_reg (s->code, X86_EDX); \
 x86_push_reg (s->code, X86_ECX); \
@@ -748,7 +748,7 @@ reg: CONV_OVF_I2 (reg) {
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_LE, TRUE, "OverflowException");      
        x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, -32768);
        // fixme: check branch
-       g_assert_not_reached ();
+       mono_assert_not_reached ();
        x86_branch8 (s->code, X86_CC_LT, -17, TRUE);
        if (tree->reg1 != tree->left->reg1)
                x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
@@ -797,11 +797,11 @@ reg: MUL_OVF (reg, reg) {
 
 reg: MUL_OVF_UN (reg, reg) {
        //fixme: implement me
-       g_assert_not_reached ();
+       mono_assert_not_reached ();
 }
 
 reg: DIV (reg, reg) {
-       g_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EAX);
 
        if (tree->left->reg1 != X86_EAX)
                x86_mov_reg_reg (s->code, X86_EAX, tree->left->reg1, 4);
@@ -809,12 +809,12 @@ reg: DIV (reg, reg) {
        x86_cdq (s->code);
        x86_div_reg (s->code, tree->right->reg1, TRUE);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
 reg: DIV_UN (reg, reg) {
-       g_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EAX);
 
        if (tree->left->reg1 != X86_EAX)
                x86_mov_reg_reg (s->code, X86_EAX, tree->left->reg1, 4);
@@ -822,35 +822,39 @@ reg: DIV_UN (reg, reg) {
        x86_cdq (s->code);
        x86_div_reg (s->code, tree->right->reg1, FALSE);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
 reg: REM (reg, reg) {
-       g_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EDX);
 
        if (tree->left->reg1 != X86_EAX)
                x86_mov_reg_reg (s->code, X86_EAX, tree->left->reg1, 4);
 
+       /* sign extend to 64bit in EAX/EDX */
        x86_cdq (s->code);
        x86_div_reg (s->code, tree->right->reg1, TRUE);
        x86_mov_reg_reg (s->code, X86_EAX, X86_EDX, 4);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
 reg: REM_UN (reg, reg) {
-       g_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EAX);
+       mono_assert (tree->right->reg1 != X86_EDX);
 
        if (tree->left->reg1 != X86_EAX)
                x86_mov_reg_reg (s->code, X86_EAX, tree->left->reg1, 4);
 
-       x86_cdq (s->code);
+       /* zero extend to 64bit in EAX/EDX */
+       x86_mov_reg_imm (s->code, X86_EDX, 0); 
        x86_div_reg (s->code, tree->right->reg1, FALSE);
        x86_mov_reg_reg (s->code, X86_EAX, X86_EDX, 4);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -1001,7 +1005,7 @@ reg: SHL (reg, reg) {
        if (tree->reg1 != tree->left->reg1)
                x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
 
-       g_assert (tree->reg1 != X86_ECX &&
+       mono_assert (tree->reg1 != X86_ECX &&
                  tree->left->reg1 != X86_ECX);
 }
 
@@ -1020,7 +1024,7 @@ reg: SHR (reg, reg) {
        if (tree->reg1 != tree->left->reg1)
                x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
 
-       g_assert (tree->reg1 != X86_ECX &&
+       mono_assert (tree->reg1 != X86_ECX &&
                  tree->left->reg1 != X86_ECX);
 }
 
@@ -1039,7 +1043,7 @@ reg: SHR_UN (reg, reg) {
        if (tree->reg1 != tree->left->reg1)
                x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
 
-       g_assert (tree->reg1 != X86_ECX &&
+       mono_assert (tree->reg1 != X86_ECX &&
                  tree->left->reg1 != X86_ECX);
 }
 
@@ -1193,7 +1197,7 @@ reg: NEWSTRUCT {
        int size = tree->data.i;        
        int sa;
        
-       g_assert (size > 0);
+       mono_assert (size > 0);
 
        sa = size + 3;
        sa &= ~3;
@@ -1599,10 +1603,10 @@ reg: CALL_I4 (this, reg) {
        if (lreg == treg || rreg == treg) 
                treg = X86_ECX;
        if (lreg == treg || rreg == treg) 
-               g_assert_not_reached ();
+               mono_assert_not_reached ();
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1619,7 +1623,7 @@ reg: CALL_I4 (this, reg) {
        
        PRINT_REG ("CALL_I4", tree->reg1);
 
-       g_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg1 == X86_EAX);
 }
 
 reg: CALL_I4 (this, ADDR_G) {
@@ -1631,7 +1635,7 @@ reg: CALL_I4 (this, ADDR_G) {
                treg = X86_EDX;
        
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1649,7 +1653,7 @@ reg: CALL_I4 (this, ADDR_G) {
 
        PRINT_REG ("CALL_I4", tree->reg1);
 
-       g_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg1 == X86_EAX);
 }
 
 reg: LDFTN (reg, INTF_ADDR) {
@@ -1671,7 +1675,7 @@ reg: CALL_I4 (this, INTF_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1692,7 +1696,7 @@ reg: CALL_I4 (this, INTF_ADDR) {
 
        PRINT_REG ("CALL_I4(INTERFACE)", tree->reg1);
 
-       g_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg1 == X86_EAX);
 }
 
 reg: LDFTN (reg, VFUNC_ADDR) {
@@ -1712,7 +1716,7 @@ reg: CALL_I4 (this, VFUNC_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1731,7 +1735,7 @@ reg: CALL_I4 (this, VFUNC_ADDR) {
 
        PRINT_REG ("CALL_I4(VIRTUAL)", tree->reg1);
 
-       g_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg1 == X86_EAX);
 }
 
 stmt: CALL_VOID (this, ADDR_G) {
@@ -1743,7 +1747,7 @@ stmt: CALL_VOID (this, ADDR_G) {
                treg = X86_EDX;
        
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1769,7 +1773,7 @@ stmt: CALL_VOID (this, INTF_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1798,7 +1802,7 @@ stmt: CALL_VOID (this, VFUNC_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -1946,7 +1950,7 @@ lreg: CONV_I8 (reg) {
        x86_branch8 (s->code, X86_CC_GE, 5, TRUE);
        i1 = s->code;
        x86_mov_reg_imm (s->code, tree->reg2, -1); 
-       g_assert ((s->code - i1) == 5);
+       mono_assert ((s->code - i1) == 5);
 }
 
 lreg: CONV_U8 (CONST_I4) 1 {
@@ -2299,7 +2303,7 @@ lreg: MUL (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2329,7 +2333,7 @@ lreg: MUL_OVF (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2359,7 +2363,7 @@ lreg: MUL_OVF_UN (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2378,7 +2382,7 @@ lreg: DIV (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2397,7 +2401,7 @@ lreg: REM (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2416,7 +2420,7 @@ lreg: DIV_UN (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2435,7 +2439,7 @@ lreg: REM_UN (lreg, lreg) {
        if (mono_regset_reg_used (s->rs, X86_ECX))
                x86_pop_reg (s->code, X86_ECX);
 
-       g_assert (tree->reg1 == X86_EAX &&
+       mono_assert (tree->reg1 == X86_EAX &&
                  tree->reg2 == X86_EDX);
 }
 
@@ -2448,7 +2452,7 @@ lreg: CALL_I8 (this, ADDR_G) {
                treg = X86_EDX;
        
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -2464,8 +2468,8 @@ lreg: CALL_I8 (this, ADDR_G) {
        if (ci->args_size)
                x86_alu_reg_imm (s->code, X86_ADD, X86_ESP, ci->args_size);
 
-       g_assert (tree->reg1 == X86_EAX);
-       g_assert (tree->reg2 == X86_EDX);
+       mono_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg2 == X86_EDX);
 }
 
 lreg: CALL_I8 (this, VFUNC_ADDR) {
@@ -2477,7 +2481,7 @@ lreg: CALL_I8 (this, VFUNC_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -2497,8 +2501,8 @@ lreg: CALL_I8 (this, VFUNC_ADDR) {
        PRINT_REG ("CALL0_I8(VIRTUAL)", tree->reg1);
        PRINT_REG ("CALL1_I8(VIRTUAL)", tree->reg2);
 
-       g_assert (tree->reg1 == X86_EAX);
-       g_assert (tree->reg2 == X86_EDX);
+       mono_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg2 == X86_EDX);
 }
 
 lreg: CALL_I8 (this, INTF_ADDR) {
@@ -2510,7 +2514,7 @@ lreg: CALL_I8 (this, INTF_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -2531,8 +2535,8 @@ lreg: CALL_I8 (this, INTF_ADDR) {
 
        PRINT_REG ("CALL_I8(INTERFACE)", tree->reg1);
 
-       g_assert (tree->reg1 == X86_EAX);
-       g_assert (tree->reg2 == X86_EDX);
+       mono_assert (tree->reg1 == X86_EAX);
+       mono_assert (tree->reg2 == X86_EDX);
 }
 
 stmt: RET (lreg) {
@@ -3137,7 +3141,7 @@ freg: CALL_R8 (this, ADDR_G) {
                treg = X86_EDX;
        
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -3163,7 +3167,7 @@ freg: CALL_R8 (this, INTF_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -3192,7 +3196,7 @@ freg: CALL_R8 (this, VFUNC_ADDR) {
                treg = X86_EDX;
 
        if (tree->left->op != MB_TERM_NOP) {
-               g_assert (lreg >= 0);
+               mono_assert (lreg >= 0);
                x86_push_reg (s->code, lreg);
        }
 
@@ -3229,7 +3233,7 @@ stmt: STIND_OBJ (reg, reg) {
        x86_push_reg (s->code, X86_EDX);
        x86_push_reg (s->code, X86_ECX);
 
-       g_assert (tree->data.i > 0);
+       mono_assert (tree->data.i > 0);
        x86_push_imm (s->code, tree->data.i);
        x86_push_reg (s->code, tree->right->reg1);
        x86_push_reg (s->code, tree->left->reg1);
@@ -3250,7 +3254,7 @@ stmt: ARG_OBJ (reg) {
        int size = tree->data.i;
        int sa;
        
-       g_assert (size > 0);
+       mono_assert (size > 0);
 
        sa = size + 3;
        sa &= ~3;
my mono mirror. check out Moved to http://github.com/mono/mono