x86.brg: use x86_widen_reg for CONV opcodes

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

diff --git a/mono/jit/ChangeLog b/mono/jit/ChangeLog
index 92976990b971db8de3b6931f3aea88dce776f326..93ad7388f45bed0470084a032c7dbe4f1c0f6e77 100644 (file)
--- a/mono/jit/ChangeLog
+++ b/mono/jit/ChangeLog
@@ -1,3 +1,7 @@
+2002-03-05  Dietmar Maurer  <dietmar@ximian.com>
+
+       * x86.brg: use x86_widen_reg for CONV opcodes
+
 2002-03-01  Dietmar Maurer  <dietmar@ximian.com>
 
        * jit.c (MAKE_SPILLED_BI_ALU): remove unnecessary assertions

diff --git a/mono/jit/x86.brg b/mono/jit/x86.brg
index 6af03abc804c28a766d14a91a818d4ab4425a250..ea20f72fb70a9498fca1f097e7299c572fc0b40d 100644 (file)
--- a/mono/jit/x86.brg
+++ b/mono/jit/x86.brg
@@ -667,17 +667,11 @@ reg: ADDR_G 5 {
 }
 
 reg: CONV_I1 (reg) {
-       x86_alu_reg_imm (s->code, X86_AND, tree->left->reg1, 0xff);
-
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, FALSE);
 }
 
 reg: CONV_I2 (reg) {
-       x86_alu_reg_imm (s->code, X86_AND, tree->left->reg1, 0xffff);
-
-       if (tree->reg1 != tree->left->reg1)                  
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, TRUE);
 }
 
 reg: CONST_I4 1 {
@@ -712,16 +706,14 @@ reg: CONV_OVF_I1 (reg) {
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_LE, TRUE, "OverflowException");      
        x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, -128);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_GT, TRUE, "OverflowException");      
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, FALSE);
 }
 
 reg: CONV_OVF_I1_UN (reg) {
        /* probe values between 0 to 128 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffffff80);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, FALSE, "OverflowException");     
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, FALSE);
 }
 
 reg: CONV_OVF_U1 (reg) {
@@ -729,8 +721,7 @@ reg: CONV_OVF_U1 (reg) {
        /* probe value to be within 0 to 255 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffffff00);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, FALSE, "OverflowException");     
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, FALSE);
 }
 
 reg: CONV_OVF_U1_UN (reg) {
@@ -738,20 +729,16 @@ reg: CONV_OVF_U1_UN (reg) {
        /* probe value to be within 0 to 255 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffffff00);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, FALSE, "OverflowException");     
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, FALSE);
 }
 
-reg: CONV_OVF_I2 (reg) {
+reg: CONV_OVF_I2 (reg) {       
        /* Probe value to be within -32768 and 32767 */
        x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, 32767);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_LE, TRUE, "OverflowException");      
        x86_alu_reg_imm (s->code, X86_CMP, tree->left->reg1, -32768);
-       // fixme: check branch
-       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);
+       EMIT_COND_SYSTEM_EXCEPTION (X86_CC_GE, TRUE, "OverflowException");      
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, TRUE);
 }
 
 reg: CONV_OVF_U2 (reg) {
@@ -759,8 +746,7 @@ reg: CONV_OVF_U2 (reg) {
        /* Probe value to be within 0 and 65535 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffff0000);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, TRUE, "OverflowException");      
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, TRUE);
 }
 
 reg: CONV_OVF_U2_UN (reg) {
@@ -768,16 +754,14 @@ reg: CONV_OVF_U2_UN (reg) {
        /* Probe value to be within 0 and 65535 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffff0000);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, FALSE, "OverflowException");     
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, TRUE);
 }
 
 reg: CONV_OVF_I2_UN (reg) {
        /* Convert uint value into short, value within 0 and 32767 */
        x86_test_reg_imm (s->code, tree->left->reg1, 0xffff8000);
        EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, FALSE, "OverflowException");     
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);     
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, FALSE, TRUE);
 }
 
 reg: MUL (reg, reg) {
@@ -1838,17 +1822,11 @@ stmt: SWITCH (reg) {
 #
 
 reg: CONV_I1 (lreg) {
-       x86_alu_reg_imm (s->code, X86_AND, tree->left->reg1, 0xff);
-
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, FALSE);
 } 
 
 reg: CONV_I2 (lreg) {
-       x86_alu_reg_imm (s->code, X86_AND, tree->left->reg1, 0xffff);
-
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
+       x86_widen_reg (s->code, tree->reg1, tree->left->reg1, TRUE, TRUE);
 } 
 
 reg: CONV_I4 (lreg) {
@@ -1923,13 +1901,6 @@ lreg: CONST_I8 1 {
        x86_mov_reg_imm (s->code, tree->reg2, *((gint32 *)&tree->data.p + 1));
 }
 
-reg: CONV_I1 (lreg) {
-       x86_alu_reg_imm (s->code, X86_AND, tree->left->reg1, 0xff);
-
-       if (tree->reg1 != tree->left->reg1)
-               x86_mov_reg_reg (s->code, tree->reg1, tree->left->reg1, 4);
-}
-
 lreg: CONV_I8 (CONST_I4) {
        x86_mov_reg_imm (s->code, tree->reg1, tree->left->data.i);
 
@@ -2812,7 +2783,7 @@ reg: CONV_I1 (freg) {
        x86_push_reg (s->code, X86_EAX); // SP = SP - 4
        x86_fist_pop_membase (s->code, X86_ESP, 0, FALSE);
        x86_pop_reg (s->code, tree->reg1);
-       x86_alu_reg_imm (s->code, X86_AND, tree->reg1, 0xff);
+       x86_widen_reg (s->code, tree->reg1, tree->reg1, TRUE, FALSE);
        x86_fldcw_membase (s->code, X86_ESP, 0);
        x86_alu_reg_imm (s->code, X86_ADD, X86_ESP, 4);
 }
@@ -2827,7 +2798,7 @@ reg: CONV_I2 (freg) {
        x86_push_reg (s->code, X86_EAX); // SP = SP - 4
        x86_fist_pop_membase (s->code, X86_ESP, 0, FALSE);
        x86_pop_reg (s->code, tree->reg1);
-       x86_alu_reg_imm (s->code, X86_AND, tree->reg1, 0xffff);
+       x86_widen_reg (s->code, tree->reg1, tree->reg1, TRUE, TRUE);
        x86_fldcw_membase (s->code, X86_ESP, 0);
        x86_alu_reg_imm (s->code, X86_ADD, X86_ESP, 4);
 }

diff --git a/mono/tests/ipaddress.cs b/mono/tests/ipaddress.cs
index c6cf4e0f94a134fa938249b26e212c51cd783187..fbb7acb8654d2df0c9ae1d190a8741b46eddbf6e 100644 (file)
--- a/mono/tests/ipaddress.cs
+++ b/mono/tests/ipaddress.cs
@@ -7,6 +7,17 @@ namespace T {
        public class T {
 
                public static int Main () {
+
+                       /*
+                       Console.WriteLine ("address is " + IPAddress.NetworkToHostOrder (0x0100007f).ToString("X"));
+                       */
+                       
+                       IPAddress testadd = IPAddress.Parse ("127.0.0.1");
+                       Console.WriteLine("address is " + testadd.Address.ToString ("X"));
+                       if (testadd.Address != 0x0100007f)
+                               return 1;
+
+                       
                        IPAddress hostadd = new IPAddress(0x0100007f);
                        Console.WriteLine("address is " + hostadd.ToString());
                        if (hostadd.ToString() != "127.0.0.1")

diff --git a/mono/tests/jit-int.cs b/mono/tests/jit-int.cs
index 0542839b866244f7e23a761174cc92dac4631536..6cb0f2127b3e94a74ece765e20c49c856996f0b6 100644 (file)
--- a/mono/tests/jit-int.cs
+++ b/mono/tests/jit-int.cs
@@ -1,5 +1,30 @@
+using System;
+
 public class TestJit {
 
+       public static int test_short ()
+       {
+               int max = 32767;
+               int min = -32768;
+
+               int t1 = 0xffeedd;
+               short s1 = (short)t1;
+               int t2 = s1;
+
+               if ((uint)t2 != 0xffffeedd) 
+                       return 1;
+               
+               Console.WriteLine (t2.ToString ("X"));
+               
+               if (Int16.Parse((min).ToString()) != -32768)
+                       return 1;
+
+               if (Int16.Parse((max).ToString()) != 32767)
+                       return 1;
+
+               return 0;
+       }
+
        public static int test_call (int a, int b) {
                return a+b;
        }
@@ -88,8 +113,13 @@ public class TestJit {
        }
 
        public static int Main() {
-               int num = 1;
+               int num = 0;
 
+               num++;
+               if (test_short () != 0)
+                       return num;
+
+               num++;
                if (test_call (3, 5) != 8)
                        return num;
                num++;