[pypy-svn] r74470 - in pypy/trunk/pypy/jit: backend/x86 metainterp

[arigo at codespeak.net]

Author: arigo
Date: Mon May 10 16:45:36 2010
New Revision: 74470

Modified:
   pypy/trunk/pypy/jit/backend/x86/assembler.py
   pypy/trunk/pypy/jit/backend/x86/regalloc.py
   pypy/trunk/pypy/jit/metainterp/optimizeopt.py
Log:
issue529 testing

Change the backend to only accept int_xxx_ovf operations immediately
followed by guard_(no)_overflow.  A corresponding fix in the front-end
to keep these two operations together.


Modified: pypy/trunk/pypy/jit/backend/x86/assembler.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/assembler.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/assembler.py	Mon May 10 16:45:36 2010
@@ -629,10 +629,6 @@
     genop_float_mul = _binaryop('MULSD', True)
     genop_float_truediv = _binaryop('DIVSD')
 
-    genop_int_mul_ovf = genop_int_mul
-    genop_int_sub_ovf = genop_int_sub
-    genop_int_add_ovf = genop_int_add
-
     genop_int_lt = _cmpop("L", "G")
     genop_int_le = _cmpop("LE", "GE")
     genop_int_eq = _cmpop("E", "E")
@@ -969,13 +965,27 @@
         self.mc.MOV(heap(self.cpu.pos_exc_value()), imm(0))
         return addr
 
-    def genop_guard_guard_no_overflow(self, ign_1, guard_op, addr,
-                                      locs, resloc):
-        return self.implement_guard(addr, self.mc.JO)
-
-    def genop_guard_guard_overflow(self, ign_1, guard_op, addr,
-                                   locs, resloc):
-        return self.implement_guard(addr, self.mc.JNO)
+    def _gen_guard_overflow(self, guard_op, addr):
+        guard_opnum = guard_op.opnum
+        if guard_opnum == rop.GUARD_NO_OVERFLOW:
+            return self.implement_guard(addr, self.mc.JO)
+        elif guard_opnum == rop.GUARD_OVERFLOW:
+            return self.implement_guard(addr, self.mc.JNO)
+        else:
+            print "int_xxx_ovf followed by", guard_op.getopname()
+            raise AssertionError
+
+    def genop_guard_int_add_ovf(self, op, guard_op, addr, arglocs, result_loc):
+        self.genop_int_add(op, arglocs, result_loc)
+        return self._gen_guard_overflow(guard_op, addr)
+
+    def genop_guard_int_sub_ovf(self, op, guard_op, addr, arglocs, result_loc):
+        self.genop_int_sub(op, arglocs, result_loc)
+        return self._gen_guard_overflow(guard_op, addr)
+
+    def genop_guard_int_mul_ovf(self, op, guard_op, addr, arglocs, result_loc):
+        self.genop_int_mul(op, arglocs, result_loc)
+        return self._gen_guard_overflow(guard_op, addr)
 
     def genop_guard_guard_false(self, ign_1, guard_op, addr, locs, ign_2):
         loc = locs[0]

Modified: pypy/trunk/pypy/jit/backend/x86/regalloc.py
==============================================================================
--- pypy/trunk/pypy/jit/backend/x86/regalloc.py	(original)
+++ pypy/trunk/pypy/jit/backend/x86/regalloc.py	Mon May 10 16:45:36 2010
@@ -322,6 +322,12 @@
             assert operations[i + 1].opnum == rop.GUARD_NOT_FORCED
             return True
         if not op.is_comparison():
+            if op.is_ovf():
+                if (operations[i + 1].opnum != rop.GUARD_NO_OVERFLOW and
+                    operations[i + 1].opnum != rop.GUARD_OVERFLOW):
+                    print "int_xxx_ovf not followed by guard_(no)_overflow"
+                    raise AssertionError
+                return True
             return False
         if (operations[i + 1].opnum != rop.GUARD_TRUE and
             operations[i + 1].opnum != rop.GUARD_FALSE):
@@ -467,9 +473,13 @@
     consider_int_or  = _consider_binop
     consider_int_xor = _consider_binop
 
-    consider_int_mul_ovf = _consider_binop
-    consider_int_sub_ovf = _consider_binop
-    consider_int_add_ovf = _consider_binop
+    def _consider_binop_with_guard(self, op, guard_op):
+        loc, argloc = self._consider_binop_part(op)
+        self.perform_with_guard(op, guard_op, [loc, argloc], loc)
+
+    consider_int_mul_ovf = _consider_binop_with_guard
+    consider_int_sub_ovf = _consider_binop_with_guard
+    consider_int_add_ovf = _consider_binop_with_guard
 
     def consider_int_neg(self, op):
         res = self.rm.force_result_in_reg(op.result, op.args[0])
@@ -1000,6 +1010,7 @@
         name = name[len('consider_'):]
         num = getattr(rop, name.upper())
         if (ResOperation(num, [], None).is_comparison()
+            or ResOperation(num, [], None).is_ovf()
             or num == rop.CALL_MAY_FORCE or num == rop.CALL_ASSEMBLER):
             oplist_with_guard[num] = value
             oplist[num] = add_none_argument(value)

Modified: pypy/trunk/pypy/jit/metainterp/optimizeopt.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/optimizeopt.py	(original)
+++ pypy/trunk/pypy/jit/metainterp/optimizeopt.py	Mon May 10 16:45:36 2010
@@ -1111,7 +1111,10 @@
             prevop = newoperations[-2]
             # - is_comparison() for cases like "int_eq/setfield_gc/guard_true"
             # - CALL_MAY_FORCE: "call_may_force/setfield_gc/guard_not_forced"
-            if ((prevop.is_comparison() or prevop.opnum == rop.CALL_MAY_FORCE)
+            # - is_ovf(): "int_add_ovf/setfield_gc/guard_no_overflow"
+            opnum = prevop.opnum
+            if ((prevop.is_comparison() or opnum == rop.CALL_MAY_FORCE
+                 or prevop.is_ovf())
                 and prevop.result not in lastop.args):
                 newoperations[-2] = lastop
                 newoperations[-1] = prevop