* x86.brg: addes basic support for itype "long"

svn path=/trunk/mono/; revision=901

diff --git a/mono/jit/ChangeLog b/mono/jit/ChangeLog
index 3f8c191b069e0a4e3b370b1d2d610477926f7e01..54cf5338592c5b90d3589c08b09bbb1a71a0c867 100644 (file)
--- a/mono/jit/ChangeLog
+++ b/mono/jit/ChangeLog
@@ -1,5 +1,7 @@
 2001-09-20  Dietmar Maurer  <dietmar@ximian.com>
 
+       * x86.brg: addes basic support for long
+
        * testjit.c (mono_compile_method): implemented POP
 
 2001-09-19  Miguel de Icaza  <miguel@ximian.com>

diff --git a/mono/jit/TODO b/mono/jit/TODO
new file mode 100644 (file)
index 0000000..b50104b
--- /dev/null
+++ b/mono/jit/TODO
@@ -0,0 +1,3 @@
+* compute the frame size
+* implement value types
+* implement a register set for FP registers (just count register usage on x86)
\ No newline at end of file

diff --git a/mono/jit/jit.c b/mono/jit/jit.c
index 31c5f467a24395e93d476653b80808a0d3e7f13d..2f73933c1606f423de46f007d60b4811132755b4 100644 (file)
--- a/mono/jit/jit.c
+++ b/mono/jit/jit.c
@@ -57,6 +57,38 @@ get_x86_regset ()
        return rs;
 }
 
+static void
+tree_preallocate_regs (MBTree *tree, int goal) 
+{
+       MBTree *kids[10];
+       int ern = mono_burg_rule (tree->state, goal);
+       guint16 *nts = mono_burg_nts [ern];
+       int i;
+       
+       mono_burg_kids (tree, ern, kids);
+
+       if (tree->reg1 < 0) { /* if not already assigned */
+
+               switch (tree->op) {
+               case MB_TERM_CALL:
+                       tree->reg1 = X86_EAX;
+                       tree->reg2 = X86_EDX;
+                       break;
+               case MB_TERM_RETV:
+                       tree->left->reg1 = X86_EAX;
+                       tree->left->reg2 = X86_EDX;
+                       break;
+               default:
+                       /* do nothing */
+               }
+
+       }
+
+       for (i = 0; nts [i]; i++) 
+               tree_preallocate_regs (kids [i], nts [i]);
+
+}
+
 static void
 tree_allocate_regs (MBTree *tree, int goal, MonoRegSet *rs) 
 {
@@ -70,14 +102,33 @@ tree_allocate_regs (MBTree *tree, int goal, MonoRegSet *rs)
        for (i = 0; nts [i]; i++) 
                tree_allocate_regs (kids [i], nts [i], rs);
 
-       for (i = 0; nts [i]; i++) 
-               mono_regset_free_reg (rs, kids [i]->reg);
+       for (i = 0; nts [i]; i++) {
+               mono_regset_free_reg (rs, kids [i]->reg1);
+               mono_regset_free_reg (rs, kids [i]->reg2);
+       }
+
+       switch (goal) {
+       case MB_NTERM_reg:
+               if ((tree->reg1 = mono_regset_alloc_reg (rs, tree->reg1)) == -1) {
+                       g_warning ("register allocation failed\n");
+                       g_assert_not_reached ();
+               }
+               break;
 
-       if (goal == MB_NTERM_reg) {
-               if ((tree->reg = mono_regset_alloc_reg (rs, -1)) == -1) {
+       case MB_NTERM_lreg:
+               if ((tree->reg1 = mono_regset_alloc_reg (rs, tree->reg1)) == -1 ||
+                   (tree->reg2 = mono_regset_alloc_reg (rs, tree->reg2)) == -1) {
                        g_warning ("register allocation failed\n");
                        g_assert_not_reached ();
                }
+               break;
+
+       case MB_NTERM_freg:
+               /* fixme: allocate floating point registers */
+               break;
+
+       default:
+               /* do nothing */
        }
 
        tree->emit = mono_burg_func [ern];
@@ -178,7 +229,8 @@ ctree_new (int op, MonoTypeEnum type, MBTree *left, MBTree *right)
        t->left = left;
        t->right = right;
        t->type = type;
-       t->reg = -1;
+       t->reg1 = -1;
+       t->reg2 = -1;
        t->is_jump = 0;
        t->jump_target = 0;
        t->last_instr = 0;
@@ -282,6 +334,7 @@ forest_allocate_regs (MBCodeGenStatus *s)
        
        for (i = 0; i < top; i++) {
                MBTree *t1 = (MBTree *) g_ptr_array_index (forest, i);
+               tree_preallocate_regs (t1, 1);
                tree_allocate_regs (t1, 1, s->rs);
        }
 
@@ -791,6 +844,14 @@ mono_compile_method (MonoMethod *method)
                        PUSH_TREE (t1);         
                        break;
               
+               case CEE_CONV_I8:
+                       ++ip;
+                       sp--;
+                       t1 = ctree_new (MB_TERM_CONV_I8, MONO_TYPE_I8, *sp, NULL);
+                       t1->cli_addr = sp [0]->cli_addr;
+                       PUSH_TREE (t1);         
+                       break;
+              
                case 0xFE:
                        ++ip;                   
                        switch (*ip) {

diff --git a/mono/jit/testjit.c b/mono/jit/testjit.c
index 31c5f467a24395e93d476653b80808a0d3e7f13d..2f73933c1606f423de46f007d60b4811132755b4 100644 (file)
--- a/mono/jit/testjit.c
+++ b/mono/jit/testjit.c
@@ -57,6 +57,38 @@ get_x86_regset ()
        return rs;
 }
 
+static void
+tree_preallocate_regs (MBTree *tree, int goal) 
+{
+       MBTree *kids[10];
+       int ern = mono_burg_rule (tree->state, goal);
+       guint16 *nts = mono_burg_nts [ern];
+       int i;
+       
+       mono_burg_kids (tree, ern, kids);
+
+       if (tree->reg1 < 0) { /* if not already assigned */
+
+               switch (tree->op) {
+               case MB_TERM_CALL:
+                       tree->reg1 = X86_EAX;
+                       tree->reg2 = X86_EDX;
+                       break;
+               case MB_TERM_RETV:
+                       tree->left->reg1 = X86_EAX;
+                       tree->left->reg2 = X86_EDX;
+                       break;
+               default:
+                       /* do nothing */
+               }
+
+       }
+
+       for (i = 0; nts [i]; i++) 
+               tree_preallocate_regs (kids [i], nts [i]);
+
+}
+
 static void
 tree_allocate_regs (MBTree *tree, int goal, MonoRegSet *rs) 
 {
@@ -70,14 +102,33 @@ tree_allocate_regs (MBTree *tree, int goal, MonoRegSet *rs)
        for (i = 0; nts [i]; i++) 
                tree_allocate_regs (kids [i], nts [i], rs);
 
-       for (i = 0; nts [i]; i++) 
-               mono_regset_free_reg (rs, kids [i]->reg);
+       for (i = 0; nts [i]; i++) {
+               mono_regset_free_reg (rs, kids [i]->reg1);
+               mono_regset_free_reg (rs, kids [i]->reg2);
+       }
+
+       switch (goal) {
+       case MB_NTERM_reg:
+               if ((tree->reg1 = mono_regset_alloc_reg (rs, tree->reg1)) == -1) {
+                       g_warning ("register allocation failed\n");
+                       g_assert_not_reached ();
+               }
+               break;
 
-       if (goal == MB_NTERM_reg) {
-               if ((tree->reg = mono_regset_alloc_reg (rs, -1)) == -1) {
+       case MB_NTERM_lreg:
+               if ((tree->reg1 = mono_regset_alloc_reg (rs, tree->reg1)) == -1 ||
+                   (tree->reg2 = mono_regset_alloc_reg (rs, tree->reg2)) == -1) {
                        g_warning ("register allocation failed\n");
                        g_assert_not_reached ();
                }
+               break;
+
+       case MB_NTERM_freg:
+               /* fixme: allocate floating point registers */
+               break;
+
+       default:
+               /* do nothing */
        }
 
        tree->emit = mono_burg_func [ern];
@@ -178,7 +229,8 @@ ctree_new (int op, MonoTypeEnum type, MBTree *left, MBTree *right)
        t->left = left;
        t->right = right;
        t->type = type;
-       t->reg = -1;
+       t->reg1 = -1;
+       t->reg2 = -1;
        t->is_jump = 0;
        t->jump_target = 0;
        t->last_instr = 0;
@@ -282,6 +334,7 @@ forest_allocate_regs (MBCodeGenStatus *s)
        
        for (i = 0; i < top; i++) {
                MBTree *t1 = (MBTree *) g_ptr_array_index (forest, i);
+               tree_preallocate_regs (t1, 1);
                tree_allocate_regs (t1, 1, s->rs);
        }
 
@@ -791,6 +844,14 @@ mono_compile_method (MonoMethod *method)
                        PUSH_TREE (t1);         
                        break;
               
+               case CEE_CONV_I8:
+                       ++ip;
+                       sp--;
+                       t1 = ctree_new (MB_TERM_CONV_I8, MONO_TYPE_I8, *sp, NULL);
+                       t1->cli_addr = sp [0]->cli_addr;
+                       PUSH_TREE (t1);         
+                       break;
+              
                case 0xFE:
                        ++ip;                   
                        switch (*ip) {

diff --git a/mono/jit/x86.brg b/mono/jit/x86.brg
index e8fca7d1fdbb5f4917e211c5357f7345360fcd4f..6093046f86bd361ab30b7d45b16882aa613945c0 100644 (file)
--- a/mono/jit/x86.brg
+++ b/mono/jit/x86.brg
@@ -35,7 +35,8 @@ struct _MBTree {
        gint32 addr;       /* address of emitted instruction */
        gint32 first_addr; /* first code address of a tree */ 
 
-       int reg;
+       gint8 reg1;
+       gint8 reg2;
        MonoTypeEnum type;
 
        union {
@@ -57,7 +58,7 @@ gboolean same_tree (MBTree *t1, MBTree *t2);
 %term LDLOC LDARG STLOC BR RET RETV ARG CALL
 %term ADD SUB MUL
 %term BLT BEQ BGE BRTRUE
-%term CONV_I4 CONV_I1 CONV_I2
+%term CONV_I4 CONV_I1 CONV_I2 CONV_I8
 #
 # we start at stmt
 #
@@ -75,39 +76,39 @@ locaddr: LDARG {
        tree->data.i = tree->data.i + 8;
 }
 
-# do nothing
-reg: CONV_I4 (reg) 
-
 reg: CONV_I1 (reg) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_imm (s->code, X86_AND, tree->reg, 0xff);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_imm (s->code, X86_AND, tree->reg1, 0xff);
 }
 
 reg: CONV_I2 (reg) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_imm (s->code, X86_AND, tree->reg, 0xffff);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_imm (s->code, X86_AND, tree->reg1, 0xffff);
 }
 
+# do nothing
+reg: CONV_I4 (reg) 
+
 reg: LDLOC {
        switch (tree->type) {
        case MONO_TYPE_I1:
-               x86_widen_membase (s->code, tree->reg, X86_EBP,
+               x86_widen_membase (s->code, tree->reg1, X86_EBP,
                                   tree->data.i, TRUE, FALSE);
                break;
        case MONO_TYPE_U1:
        case MONO_TYPE_BOOLEAN:
-               x86_widen_membase (s->code, tree->reg, X86_EBP,
+               x86_widen_membase (s->code, tree->reg1, X86_EBP,
                                   tree->data.i, FALSE, FALSE);
                break;
        case MONO_TYPE_I2:
-               x86_widen_membase (s->code, tree->reg, X86_EBP,
+               x86_widen_membase (s->code, tree->reg1, X86_EBP,
                                   tree->data.i, TRUE, TRUE);
                break;
        case MONO_TYPE_U2:
        case MONO_TYPE_CHAR:
-               x86_widen_membase (s->code, tree->reg, X86_EBP,
+               x86_widen_membase (s->code, tree->reg1, X86_EBP,
                                   tree->data.i, FALSE, TRUE);
                break;
 
@@ -117,7 +118,7 @@ reg: LDLOC {
        case MONO_TYPE_CLASS:
        case MONO_TYPE_STRING:
        case MONO_TYPE_PTR:
-               x86_mov_reg_membase (s->code, tree->reg, X86_EBP,
+               x86_mov_reg_membase (s->code, tree->reg1, X86_EBP,
                                     tree->data.i, 4);
                break;
        default:
@@ -127,7 +128,8 @@ reg: LDLOC {
 } cost {
        MBCOND (tree->type != MONO_TYPE_R4 &&
                tree->type != MONO_TYPE_R8 &&
-               tree->type != MONO_TYPE_I8);
+               tree->type != MONO_TYPE_I8 &&
+               tree->type != MONO_TYPE_U8);
 
        return 1;
 }
@@ -146,7 +148,7 @@ reg: LDARG {
        case MONO_TYPE_CLASS:
        case MONO_TYPE_STRING:
        case MONO_TYPE_PTR:
-               x86_mov_reg_membase (s->code, tree->reg, X86_EBP,
+               x86_mov_reg_membase (s->code, tree->reg1, X86_EBP,
                                     tree->data.i + 8, 4);
                break;
        default:
@@ -156,40 +158,41 @@ reg: LDARG {
 } cost {
        MBCOND (tree->type != MONO_TYPE_R4 &&
                tree->type != MONO_TYPE_R8 &&
-               tree->type != MONO_TYPE_I8);
+               tree->type != MONO_TYPE_I8 &&
+               tree->type != MONO_TYPE_U8);
 
        return 1;
 }
 
 
 reg: MUL (reg, reg) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_imul_reg_reg (s->code, tree->reg, tree->right->reg);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_imul_reg_reg (s->code, tree->reg1, tree->right->reg1);
 }
 
 reg: ADD (reg, CONST_I4) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_imm (s->code, X86_ADD, tree->reg, tree->right->data.i);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_imm (s->code, X86_ADD, tree->reg1, tree->right->data.i);
 }
 
 reg: ADD (reg, reg) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_reg (s->code, X86_ADD, tree->reg, tree->right->reg);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_reg (s->code, X86_ADD, tree->reg1, tree->right->reg1);
 }
 
 reg: SUB (reg, CONST_I4) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_imm (s->code, X86_SUB, tree->reg, tree->right->data.i);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_imm (s->code, X86_SUB, tree->reg1, tree->right->data.i);
 }
 
 reg: SUB (reg, reg) {
-       if (tree->reg != tree->left->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->left->reg, 4);
-       x86_alu_reg_reg (s->code, X86_SUB, tree->reg, tree->right->reg);
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_alu_reg_reg (s->code, X86_SUB, tree->reg1, tree->right->reg1);
 }
 
 stmt: STLOC (CONST_I4) {
@@ -203,13 +206,13 @@ stmt: STLOC (reg) {
        case MONO_TYPE_U1:
        case MONO_TYPE_BOOLEAN:
                x86_mov_membase_reg (s->code, X86_EBP, tree->data.i,
-                                    tree->left->reg, 1);
+                                    tree->left->reg1, 1);
                break;
        case MONO_TYPE_I2:
        case MONO_TYPE_U2:
        case MONO_TYPE_CHAR:
                x86_mov_membase_reg (s->code, X86_EBP, tree->data.i,
-                                    tree->left->reg, 2);
+                                    tree->left->reg1, 2);
                break;
        case MONO_TYPE_I:
        case MONO_TYPE_I4:
@@ -218,7 +221,7 @@ stmt: STLOC (reg) {
        case MONO_TYPE_STRING:
        case MONO_TYPE_PTR:
                x86_mov_membase_reg (s->code, X86_EBP, tree->data.i,
-                                    tree->left->reg, 4);
+                                    tree->left->reg1, 4);
                break;
        default:
                g_warning ("unknown type %02x", tree->type);
@@ -236,7 +239,7 @@ stmt: BLT (reg, CONST_I4) {
        gint32 offset;
 
        tree->is_jump = 1;
-       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg, tree->right->data.i);
+       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, tree->right->data.i);
        offset = 6 + s->code - start;
        x86_branch32 (s->code, X86_CC_LT, tree->data.i - offset, TRUE); 
 }
@@ -246,7 +249,7 @@ stmt: BEQ (reg, CONST_I4) {
        gint32 offset;
 
        tree->is_jump = 1;
-       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg, tree->right->data.i);
+       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, tree->right->data.i);
        offset = 6 + s->code - start;
        x86_branch32 (s->code, X86_CC_EQ, tree->data.i - offset, TRUE);
 }
@@ -256,7 +259,7 @@ stmt: BGE (reg, CONST_I4) {
        gint32 offset;
 
        tree->is_jump = 1;
-       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg, tree->right->data.i);
+       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, tree->right->data.i);
        offset = 6 + s->code - start;
        x86_branch32 (s->code, X86_CC_GE, tree->data.i - offset, TRUE);
 }
@@ -266,7 +269,7 @@ stmt: BRTRUE (reg) {
        gint32 offset;
 
        tree->is_jump = 1;
-       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg, 0);
+       x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, 0);
        offset = 6 + s->code - start;
        x86_branch32 (s->code, X86_CC_NE, tree->data.i - offset, TRUE);
 }
@@ -278,7 +281,7 @@ stmt: RETV (reg) {
                x86_jump32 (s->code, tree->data.i - 5);      
        }
 
-       g_assert (tree->left->reg == X86_EAX); // return must be in EAX
+       g_assert (tree->left->reg1 == X86_EAX); // return must be in EAX
 }
 
 stmt: RET {
@@ -293,7 +296,7 @@ stmt: ARG (CONST_I4) {
 }
 
 stmt: ARG (reg) {
-       x86_push_reg (s->code, tree->left->reg);
+       x86_push_reg (s->code, tree->left->reg1);
 }
 
 reg: CALL {
@@ -313,7 +316,7 @@ reg: CALL {
                x86_mov_reg_imm (s->code, X86_EAX, tree->data.p);
                x86_call_membase (s->code, X86_EAX, 
                                  G_STRUCT_OFFSET (MonoMethod, addr));
-               g_assert (tree->reg == X86_EAX);
+               g_assert (tree->reg1 == X86_EAX);
                break;
        default:
                g_warning ("unknown type %02x", tree->type);
@@ -322,7 +325,8 @@ reg: CALL {
 } cost {
        MBCOND (tree->type != MONO_TYPE_R4 &&
                tree->type != MONO_TYPE_R8 &&
-               tree->type != MONO_TYPE_I8);
+               tree->type != MONO_TYPE_I8 &&
+               tree->type != MONO_TYPE_U8);
 
        return 1;
 }
@@ -333,6 +337,128 @@ stmt: CALL {
        x86_call_membase (s->code, X86_EAX, G_STRUCT_OFFSET (MonoMethod, addr));
 }
 
+#
+# 64 bit integers
+#
+
+lreg: CONV_I8 (CONST_I4) {
+       x86_mov_reg_imm (s->code, tree->reg1, tree->left->data.i);
+
+       if (tree->left->data.i >= 0)
+               x86_alu_reg_reg (s->code, X86_XOR, tree->reg2, tree->reg2);
+       else 
+               x86_mov_reg_imm (s->code, tree->reg1, -1);              
+}
+
+stmt: STLOC (lreg) {
+       x86_mov_membase_reg (s->code, X86_EBP, tree->data.i,
+                            tree->left->reg1, 4);
+       x86_mov_membase_reg (s->code, X86_EBP, tree->data.i + 4,
+                            tree->left->reg2, 4);
+}
+
+lreg: LDARG {
+       x86_mov_reg_membase (s->code, tree->reg1, X86_EBP,
+                            tree->data.i + 8, 4);
+       x86_mov_reg_membase (s->code, tree->reg2, X86_EBP,
+                            tree->data.i + 8 + 4, 4);
+} cost {
+       MBCOND (tree->type == MONO_TYPE_I8 ||
+               tree->type == MONO_TYPE_U8);
+       return 0;
+}
+
+lreg: LDLOC {
+       x86_mov_reg_membase (s->code, tree->reg1, X86_EBP,
+                            tree->data.i, 4);
+       x86_mov_reg_membase (s->code, tree->reg2, X86_EBP,
+                            tree->data.i + 4, 4);
+} cost {
+       MBCOND (tree->type == MONO_TYPE_I8 ||
+               tree->type == MONO_TYPE_U8);
+       return 0;
+}
+
+lreg: SUB (lreg, lreg) {
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       if (tree->reg2 != tree->left->reg2)
+               x86_mov_reg_reg (s->code, tree->reg2, tree->left->reg2, 4);
+       x86_alu_reg_reg (s->code, X86_SUB, tree->reg1, tree->right->reg1);
+       x86_alu_reg_reg (s->code, X86_SUB, tree->reg2, tree->right->reg2);
+}
+
+lreg: ADD (lreg, lreg) {
+       if (tree->reg1 != tree->left->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       if (tree->reg2 != tree->left->reg2)
+               x86_mov_reg_reg (s->code, tree->reg2, tree->left->reg2, 4);
+       x86_alu_reg_reg (s->code, X86_ADD, tree->reg1, tree->right->reg1);
+       x86_alu_reg_reg (s->code, X86_ADC, tree->reg2, tree->right->reg2);
+}
+
+lreg: CALL {
+       x86_mov_reg_imm (s->code, X86_EAX, tree->data.p);
+       x86_call_membase (s->code, X86_EAX, 
+                         G_STRUCT_OFFSET (MonoMethod, addr));
+} cost {
+       MBCOND (tree->type == MONO_TYPE_I8 ||
+               tree->type == MONO_TYPE_U8);
+       return 0;
+}
+
+stmt: RETV (lreg) {
+
+       if (!tree->last_instr) {
+               tree->is_jump = 1;
+               x86_jump32 (s->code, tree->data.i - 5);      
+       }
+       g_assert (tree->left->reg1 == X86_EAX); // return must be in EAX
+       g_assert (tree->left->reg2 == X86_EDX); // return must be in EDX
+}
+
+
+stmt: ARG (lreg) {
+       x86_push_reg (s->code, tree->left->reg2);
+       x86_push_reg (s->code, tree->left->reg1);
+}
+
+stmt: BEQ (lreg, lreg) {
+       guint8 *start = s->code;
+       gint32 o1, o2, i;
+
+       tree->is_jump = 1;
+
+       for (i = 0; i < 2; i ++) {
+               s->code = start;
+               x86_alu_reg_reg (s->code, X86_CMP, tree->left->reg1, tree->right->reg1);
+               o1 = 2 + s->code - start;
+               x86_branch8 (s->code, X86_CC_NE, o2 - o1, FALSE);
+               x86_alu_reg_reg (s->code, X86_CMP, tree->left->reg2, tree->right->reg2);
+               o2 = 6 + s->code - start;
+               x86_branch32 (s->code, X86_CC_EQ, tree->data.i - o2, TRUE);
+       }
+}
+stmt: BGE (lreg, lreg) {
+       guint8 *start = s->code;
+       gint32 o1, o2, oe, i;
+
+       tree->is_jump = 1;
+
+       for (i = 0; i < 2; i ++) {
+               s->code = start;
+               x86_alu_reg_reg (s->code, X86_CMP, tree->left->reg2, tree->right->reg2);
+               o1 = 6 + s->code - start;
+               x86_branch32 (s->code, X86_CC_GT,  tree->data.i - o1, TRUE);
+               x86_alu_reg_reg (s->code, X86_CMP, tree->left->reg2, tree->right->reg2);
+               o2 = 2 + s->code - start;
+               x86_branch8 (s->code, X86_CC_NE, oe - o2, TRUE);
+               x86_alu_reg_reg (s->code, X86_CMP, tree->left->reg1, tree->right->reg1);
+               oe = 6 + s->code - start;
+               x86_branch32 (s->code, X86_CC_GE, tree->data.i - oe, FALSE);
+       }
+}
+
 #
 # floating point 
 # fixme: dont know how to assign registers?
@@ -405,8 +531,6 @@ stmt: RETV (freg) {
                tree->is_jump = 1;
                x86_jump32 (s->code, tree->data.i - 5);      
        }
-
-       //g_assert (tree->left->reg == X86_EAX); // return must be in EAX
 }
 
 
@@ -415,9 +539,9 @@ stmt: RETV (freg) {
 #
 
 reg: ADD (locaddr, reg) {
-       if (tree->reg != tree->right->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->right->reg, 4);
-       x86_alu_reg_membase (s->code, X86_ADD, tree->reg, X86_EBP, 
+       if (tree->reg1 != tree->right->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->right->reg1, 4);
+       x86_alu_reg_membase (s->code, X86_ADD, tree->reg1, X86_EBP, 
                             tree->left->data.i);       
 } cost {
        MBCOND (tree->left->type == MONO_TYPE_I4 ||
@@ -426,9 +550,9 @@ reg: ADD (locaddr, reg) {
 }
 
 reg: MUL (locaddr, reg) {
-       if (tree->reg != tree->right->reg)
-               x86_mov_reg_reg (s->code, tree->reg, tree->right->reg, 4);
-       x86_imul_reg_membase (s->code, tree->reg, X86_EBP, tree->left->data.i);
+       if (tree->reg1 != tree->right->reg1)
+               x86_mov_reg_reg (s->code, tree->reg1, tree->right->reg1, 4);
+       x86_imul_reg_membase (s->code, tree->reg1, X86_EBP, tree->left->data.i);
 } cost {
        MBCOND (tree->left->type == MONO_TYPE_I4 ||
                tree->left->type == MONO_TYPE_U4);

diff --git a/mono/wrapper/ChangeLog b/mono/wrapper/ChangeLog
index e8228acce08d063a88ae442414e2cff271346d38..92aec6f09b4e9afd90cac21dd6d67b6d65179ac7 100644 (file)
--- a/mono/wrapper/ChangeLog
+++ b/mono/wrapper/ChangeLog
@@ -1,3 +1,7 @@
+2001-09-20  Dietmar Maurer  <dietmar@ximian.com>
+
+       * wrapper.c: added declaration of environ
+
 2001-09-07  Nick Drochak  <ndrochak@gol.com>
 
        * Makefile.am: Use '=' to set CLEANFILES instead of '+=' since 

diff --git a/mono/wrapper/wrapper.c b/mono/wrapper/wrapper.c
index 1832312f3972b48d71d792d3899fcd3097e4d8ed..019ae2711fd217912fc51bdb52660e6f27cfe017 100644 (file)
--- a/mono/wrapper/wrapper.c
+++ b/mono/wrapper/wrapper.c
@@ -1,10 +1,12 @@
 #include <config.h>
 #include <limits.h>
-#include <dirent.h>\r
-#include <stdlib.h>\r
+#include <dirent.h>
+#include <stdlib.h>
 
 #include "wrapper.h"
 
+extern char **environ;
+
 gint64
 mono_wrapper_seek (gpointer fd, gint64 offset, gint32 whence)
 {
@@ -59,7 +61,7 @@ mono_wrapper_ftruncate (gpointer fd, gint64 length)
 gpointer
 mono_wrapper_open (const char * path, gint32 flags, gint32 mode)
 {
-       return (gpointer)open (path, flags, mode);
+       return (gpointer) open (path, flags, mode);
 }
 
 gint32
@@ -96,32 +98,33 @@ mono_wrapper_unlink (const char * path)
 }
 
 gpointer
-mono_wrapper_opendir (const char * path)\r
-{\r
-       return (gpointer)opendir(path);\r
+mono_wrapper_opendir (const char * path)
+{
+       return (gpointer)opendir(path);
 }
 
 const char *
-mono_wrapper_readdir (gpointer dir)\r
-{\r
-       struct dirent* p = readdir((DIR*)dir);\r
-       return p != NULL ? p->d_name : NULL;\r
+mono_wrapper_readdir (gpointer dir)
+{
+       struct dirent* p = readdir((DIR*)dir);
+       return p != NULL ? p->d_name : NULL;
 }
 
 gint32
-mono_wrapper_closedir (gpointer dir)\r
-{\r
-       return closedir((DIR*)dir);\r
+mono_wrapper_closedir (gpointer dir)
+{
+       return closedir((DIR*)dir);
 }
 
 gpointer
-mono_wrapper_getenv (const char * variable)\r
-{\r
-       return (gpointer)getenv(variable);\r
+mono_wrapper_getenv (const char * variable)
+{
+       return (gpointer)getenv(variable);
 }
-\r
+
 gpointer
-mono_wrapper_environ ()\r
-{\r
-       return (gpointer)environ;\r
-}\r
+mono_wrapper_environ ()
+{
+       return (gpointer)environ;
+}
+