[pypy-commit] pypy optresult: finish porting test_optimizebasic

fijal noreply at buildbot.pypy.org
Tue Dec 2 19:22:42 CET 2014


Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: optresult
Changeset: r74787:e2c252e3b7eb
Date: 2014-12-02 20:22 +0200
http://bitbucket.org/pypy/pypy/changeset/e2c252e3b7eb/

Log:	finish porting test_optimizebasic

diff --git a/rpython/jit/metainterp/optimizeopt/intbounds.py b/rpython/jit/metainterp/optimizeopt/intbounds.py
--- a/rpython/jit/metainterp/optimizeopt/intbounds.py
+++ b/rpython/jit/metainterp/optimizeopt/intbounds.py
@@ -151,8 +151,8 @@
                 # nonneg % power-of-two ==> nonneg & (power-of-two - 1)
                 arg1 = op.getarg(0)
                 arg2 = ConstInt(val-1)
-                xxx
-                op = op.copy_and_change(rop.INT_AND, args=[arg1, arg2])
+                op = self.replace_op_with(op, rop.INT_AND,
+                                          args=[arg1, arg2])
         self.emit_operation(op)
         if v2.is_constant():
             val = v2.box.getint()
@@ -268,8 +268,7 @@
         v2 = self.getvalue(op.getarg(1))
         resbound = v1.intbound.mul_bound(v2.intbound)
         if resbound.bounded():
-            xxx
-            op = op.copy_and_change(rop.INT_MUL)
+            op = self.replace_op_with(op, rop.INT_MUL)
         self.emit_operation(op)
         r = self.getvalue(op)
         r.intbound.intersect(resbound)
@@ -482,9 +481,9 @@
                 v1 = self.getvalue(op.getarg(0))
                 v2 = self.getvalue(op.getarg(1))
                 if v1.intbound.intersect(v2.intbound):
-                    self.propagate_bounds_backward(op.getarg(0))
+                    self.propagate_bounds_backward(op.getarg(0), v1)
                 if v2.intbound.intersect(v1.intbound):
-                    self.propagate_bounds_backward(op.getarg(1))
+                    self.propagate_bounds_backward(op.getarg(1), v2)
 
     def propagate_bounds_INT_IS_TRUE(self, op):
         r = self.getvalue(op)
@@ -535,10 +534,10 @@
         r = self.getvalue(op)
         b = r.intbound.div_bound(v2.intbound)
         if v1.intbound.intersect(b):
-            self.propagate_bounds_backward(op.getarg(0))
+            self.propagate_bounds_backward(op.getarg(0), v1)
         b = r.intbound.div_bound(v1.intbound)
         if v2.intbound.intersect(b):
-            self.propagate_bounds_backward(op.getarg(1))
+            self.propagate_bounds_backward(op.getarg(1), v2)
 
     def propagate_bounds_INT_LSHIFT(self, op):
         v1 = self.getvalue(op.getarg(0))
diff --git a/rpython/jit/metainterp/optimizeopt/optimizer.py b/rpython/jit/metainterp/optimizeopt/optimizer.py
--- a/rpython/jit/metainterp/optimizeopt/optimizer.py
+++ b/rpython/jit/metainterp/optimizeopt/optimizer.py
@@ -293,8 +293,8 @@
     def getvalue(self, box):
         return self.optimizer.getvalue(box)
 
-    def replace_op_with(self, op, newopnum, args=None):
-        return self.optimizer.replace_op_with(op, newopnum, args)
+    def replace_op_with(self, op, newopnum, args=None, descr=None):
+        return self.optimizer.replace_op_with(op, newopnum, args, descr)
 
     def make_constant(self, box, constbox):
         return self.optimizer.make_constant(box, constbox)
@@ -466,6 +466,8 @@
     def get_constant_box(self, box):
         if isinstance(box, Const):
             return box
+        while box.source_op is not None:
+            box = box.source_op
         try:
             value = self.values[box]
             self.ensure_imported(value)
@@ -494,15 +496,17 @@
 
     def make_constant(self, box, constbox):
         try:
+            while box.source_op is not None:
+                box = box.source_op
             value = self.values[box]
             value.level = LEVEL_CONSTANT
             value.make_constant(constbox)
         except KeyError:
             self.values[box] = ConstantValue(constbox)
 
-    def replace_op_with(self, op, newopnum, args=None):
+    def replace_op_with(self, op, newopnum, args=None, descr=None):
         v = self.getvalue(op)
-        newop = op.copy_and_change(newopnum, args=args)
+        newop = op.copy_and_change(newopnum, args=args, descr=descr)
         v.box = newop
         return newop
 
diff --git a/rpython/jit/metainterp/optimizeopt/rewrite.py b/rpython/jit/metainterp/optimizeopt/rewrite.py
--- a/rpython/jit/metainterp/optimizeopt/rewrite.py
+++ b/rpython/jit/metainterp/optimizeopt/rewrite.py
@@ -114,7 +114,7 @@
         if v2.is_constant() and v2.box.getint() == 0:
             self.make_equal_to(op, v1)
         elif v1.is_constant() and v1.box.getint() == 0:
-            op = op.copy_and_change(rop.INT_NEG, args=[v2.box])
+            op = self.replace_op_with(op, rop.INT_NEG, args=[v2.box])
             self.emit_operation(op)
         elif v1 is v2:
             self.make_constant_int(op, 0)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -4131,7 +4131,7 @@
     def test_str_concat_1(self):
         ops = """
         [p1, p2]
-        p3 = call(0, p1, p2, descr=strconcatdescr)
+        p3 = call_r(0, p1, p2, descr=strconcatdescr)
         jump(p2, p3)
         """
         expected = """
@@ -4152,7 +4152,7 @@
         p1 = newstr(2)
         strsetitem(p1, 0, i0)
         strsetitem(p1, 1, i1)
-        p3 = call(0, p1, p2, descr=strconcatdescr)
+        p3 = call_r(0, p1, p2, descr=strconcatdescr)
         jump(i1, i0, p3)
         """
         expected = """
@@ -4173,7 +4173,7 @@
         p1 = newstr(2)
         strsetitem(p1, 0, i0)
         strsetitem(p1, 1, i1)
-        p3 = call(0, p2, p1, descr=strconcatdescr)
+        p3 = call_r(0, p2, p1, descr=strconcatdescr)
         jump(i1, i0, p3)
         """
         expected = """
@@ -4193,8 +4193,8 @@
     def test_str_concat_str_str_str(self):
         ops = """
         [p1, p2, p3]
-        p4 = call(0, p1, p2, descr=strconcatdescr)
-        p5 = call(0, p4, p3, descr=strconcatdescr)
+        p4 = call_r(0, p1, p2, descr=strconcatdescr)
+        p5 = call_r(0, p4, p3, descr=strconcatdescr)
         jump(p2, p3, p5)
         """
         expected = """
@@ -4215,7 +4215,7 @@
     def test_str_concat_str_cstr1(self):
         ops = """
         [p2]
-        p3 = call(0, p2, s"x", descr=strconcatdescr)
+        p3 = call_r(0, p2, s"x", descr=strconcatdescr)
         jump(p3)
         """
         expected = """
@@ -4232,9 +4232,9 @@
     def test_str_concat_consts(self):
         ops = """
         []
-        p1 = same_as(s"ab")
-        p2 = same_as(s"cde")
-        p3 = call(0, p1, p2, descr=strconcatdescr)
+        p1 = same_as_r(s"ab")
+        p2 = same_as_r(s"cde")
+        p3 = call_r(0, p1, p2, descr=strconcatdescr)
         escape(p3)
         jump()
         """
@@ -4251,8 +4251,8 @@
         p0 = newstr(1)
         strsetitem(p0, 0, i0)
         p1 = newstr(0)
-        p2 = call(0, p0, p1, descr=strconcatdescr)
-        i1 = call(0, p2, p0, descr=strequaldescr)
+        p2 = call_r(0, p0, p1, descr=strconcatdescr)
+        i1 = call_i(0, p2, p0, descr=strequaldescr)
         finish(i1)
         """
         expected = """
@@ -4267,8 +4267,8 @@
         p0 = newstr(0)
         p1 = newstr(1)
         strsetitem(p1, 0, i0)
-        p2 = call(0, p0, p1, descr=strconcatdescr)
-        i1 = call(0, p2, p1, descr=strequaldescr)
+        p2 = call_r(0, p0, p1, descr=strconcatdescr)
+        i1 = call_i(0, p2, p1, descr=strequaldescr)
         finish(i1)
         """
         expected = """
@@ -4280,7 +4280,7 @@
     def test_str_slice_1(self):
         ops = """
         [p1, i1, i2]
-        p2 = call(0, p1, i1, i2, descr=strslicedescr)
+        p2 = call_r(0, p1, i1, i2, descr=strslicedescr)
         jump(p2, i1, i2)
         """
         expected = """
@@ -4295,7 +4295,7 @@
     def test_str_slice_2(self):
         ops = """
         [p1, i2]
-        p2 = call(0, p1, 0, i2, descr=strslicedescr)
+        p2 = call_r(0, p1, 0, i2, descr=strslicedescr)
         jump(p2, i2)
         """
         expected = """
@@ -4309,8 +4309,8 @@
     def test_str_slice_3(self):
         ops = """
         [p1, i1, i2, i3, i4]
-        p2 = call(0, p1, i1, i2, descr=strslicedescr)
-        p3 = call(0, p2, i3, i4, descr=strslicedescr)
+        p2 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        p3 = call_r(0, p2, i3, i4, descr=strslicedescr)
         jump(p3, i1, i2, i3, i4)
         """
         expected = """
@@ -4327,7 +4327,7 @@
     def test_str_slice_getitem1(self):
         ops = """
         [p1, i1, i2, i3]
-        p2 = call(0, p1, i1, i2, descr=strslicedescr)
+        p2 = call_r(0, p1, i1, i2, descr=strslicedescr)
         i4 = strgetitem(p2, i3)
         escape(i4)
         jump(p1, i1, i2, i3)
@@ -4348,7 +4348,7 @@
         p1 = newstr(2)
         strsetitem(p1, 0, i3)
         strsetitem(p1, 1, i4)
-        p2 = call(0, p1, 1, 2, descr=strslicedescr)
+        p2 = call_r(0, p1, 1, 2, descr=strslicedescr)
         i5 = strgetitem(p2, 0)
         escape(i5)
         jump(i3, i4)
@@ -4363,8 +4363,8 @@
     def test_str_slice_concat(self):
         ops = """
         [p1, i1, i2, p2]
-        p3 = call(0, p1, i1, i2, descr=strslicedescr)
-        p4 = call(0, p3, p2, descr=strconcatdescr)
+        p3 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        p4 = call_r(0, p3, p2, descr=strconcatdescr)
         jump(p4, i1, i2, p2)
         """
         expected = """
@@ -4384,7 +4384,7 @@
         []
         p0 = newstr(11)
         copystrcontent(s"hello world", p0, 0, 0, 11)
-        p1 = call(0, p0, 0, 5, descr=strslicedescr)
+        p1 = call_r(0, p0, 0, 5, descr=strslicedescr)
         finish(p1)
         """
         expected = """
@@ -4415,7 +4415,7 @@
     def test_str_equal_noop1(self):
         ops = """
         [p1, p2]
-        i0 = call(0, p1, p2, descr=strequaldescr)
+        i0 = call_i(0, p1, p2, descr=strequaldescr)
         escape(i0)
         jump(p1, p2)
         """
@@ -4424,8 +4424,8 @@
     def test_str_equal_noop2(self):
         ops = """
         [p1, p2, p3]
-        p4 = call(0, p1, p2, descr=strconcatdescr)
-        i0 = call(0, p3, p4, descr=strequaldescr)
+        p4 = call_r(0, p1, p2, descr=strconcatdescr)
+        i0 = call_i(0, p3, p4, descr=strequaldescr)
         escape(i0)
         jump(p1, p2, p3)
         """
@@ -4437,7 +4437,7 @@
         p4 = newstr(i3)
         copystrcontent(p1, p4, 0, 0, i1)
         copystrcontent(p2, p4, 0, i1, i2)
-        i0 = call(0, p3, p4, descr=strequaldescr)
+        i0 = call_i(0, p3, p4, descr=strequaldescr)
         escape(i0)
         jump(p1, p2, p3)
         """
@@ -4446,15 +4446,15 @@
     def test_str_equal_slice1(self):
         ops = """
         [p1, i1, i2, p3]
-        p4 = call(0, p1, i1, i2, descr=strslicedescr)
-        i0 = call(0, p4, p3, descr=strequaldescr)
+        p4 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        i0 = call_i(0, p4, p3, descr=strequaldescr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
         expected = """
         [p1, i1, i2, p3]
         i3 = int_sub(i2, i1)
-        i0 = call(0, p1, i1, i3, p3, descr=streq_slice_checknull_descr)
+        i0 = call_i(0, p1, i1, i3, p3, descr=streq_slice_checknull_descr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
@@ -4463,15 +4463,15 @@
     def test_str_equal_slice2(self):
         ops = """
         [p1, i1, i2, p3]
-        p4 = call(0, p1, i1, i2, descr=strslicedescr)
-        i0 = call(0, p3, p4, descr=strequaldescr)
+        p4 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        i0 = call_i(0, p3, p4, descr=strequaldescr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
         expected = """
         [p1, i1, i2, p3]
         i4 = int_sub(i2, i1)
-        i0 = call(0, p1, i1, i4, p3, descr=streq_slice_checknull_descr)
+        i0 = call_i(0, p1, i1, i4, p3, descr=streq_slice_checknull_descr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
@@ -4481,8 +4481,8 @@
         ops = """
         [p1, i1, i2, p3]
         guard_nonnull(p3) []
-        p4 = call(0, p1, i1, i2, descr=strslicedescr)
-        i0 = call(0, p3, p4, descr=strequaldescr)
+        p4 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        i0 = call_i(0, p3, p4, descr=strequaldescr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
@@ -4490,7 +4490,7 @@
         [p1, i1, i2, p3]
         guard_nonnull(p3) []
         i4 = int_sub(i2, i1)
-        i0 = call(0, p1, i1, i4, p3, descr=streq_slice_nonnull_descr)
+        i0 = call_i(0, p1, i1, i4, p3, descr=streq_slice_nonnull_descr)
         escape(i0)
         jump(p1, i1, i2, p3)
         """
@@ -4499,15 +4499,15 @@
     def test_str_equal_slice4(self):
         ops = """
         [p1, i1, i2]
-        p3 = call(0, p1, i1, i2, descr=strslicedescr)
-        i0 = call(0, p3, s"x", descr=strequaldescr)
+        p3 = call_r(0, p1, i1, i2, descr=strslicedescr)
+        i0 = call_i(0, p3, s"x", descr=strequaldescr)
         escape(i0)
         jump(p1, i1, i2)
         """
         expected = """
         [p1, i1, i2]
         i3 = int_sub(i2, i1)
-        i0 = call(0, p1, i1, i3, 120, descr=streq_slice_char_descr)
+        i0 = call_i(0, p1, i1, i3, 120, descr=streq_slice_char_descr)
         escape(i0)
         jump(p1, i1, i2)
         """
@@ -4516,17 +4516,17 @@
     def test_str_equal_slice5(self):
         ops = """
         [p1, i1, i2, i3]
-        p4 = call(0, p1, i1, i2, descr=strslicedescr)
+        p4 = call_r(0, p1, i1, i2, descr=strslicedescr)
         p5 = newstr(1)
         strsetitem(p5, 0, i3)
-        i0 = call(0, p5, p4, descr=strequaldescr)
+        i0 = call_i(0, p5, p4, descr=strequaldescr)
         escape(i0)
         jump(p1, i1, i2, i3)
         """
         expected = """
         [p1, i1, i2, i3]
         i4 = int_sub(i2, i1)
-        i0 = call(0, p1, i1, i4, i3, descr=streq_slice_char_descr)
+        i0 = call_i(0, p1, i1, i4, i3, descr=streq_slice_char_descr)
         escape(i0)
         jump(p1, i1, i2, i3)
         """
@@ -4535,7 +4535,7 @@
     def test_str_equal_none1(self):
         ops = """
         [p1]
-        i0 = call(0, p1, NULL, descr=strequaldescr)
+        i0 = call_i(0, p1, NULL, descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
@@ -4550,7 +4550,7 @@
     def test_str_equal_none2(self):
         ops = """
         [p1]
-        i0 = call(0, NULL, p1, descr=strequaldescr)
+        i0 = call_i(0, NULL, p1, descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
@@ -4566,14 +4566,14 @@
         ops = """
         [p1]
         guard_nonnull(p1) []
-        i0 = call(0, p1, s"hello world", descr=strequaldescr)
+        i0 = call_i(0, p1, s"hello world", descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
         expected = """
         [p1]
         guard_nonnull(p1) []
-        i0 = call(0, p1, s"hello world", descr=streq_nonnull_descr)
+        i0 = call_i(0, p1, s"hello world", descr=streq_nonnull_descr)
         escape(i0)
         jump(p1)
         """
@@ -4583,7 +4583,7 @@
         ops = """
         [p1]
         guard_nonnull(p1) []
-        i0 = call(0, p1, s"", descr=strequaldescr)
+        i0 = call_i(0, p1, s"", descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
@@ -4601,14 +4601,14 @@
         ops = """
         [p1]
         guard_nonnull(p1) []
-        i0 = call(0, p1, s"x", descr=strequaldescr)
+        i0 = call_i(0, p1, s"x", descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
         expected = """
         [p1]
         guard_nonnull(p1) []
-        i0 = call(0, p1, 120, descr=streq_nonnull_char_descr)
+        i0 = call_i(0, p1, 120, descr=streq_nonnull_char_descr)
         escape(i0)
         jump(p1)
         """
@@ -4617,8 +4617,8 @@
     def test_str_equal_nonnull4(self):
         ops = """
         [p1, p2]
-        p4 = call(0, p1, p2, descr=strconcatdescr)
-        i0 = call(0, s"hello world", p4, descr=strequaldescr)
+        p4 = call_r(0, p1, p2, descr=strconcatdescr)
+        i0 = call_i(0, s"hello world", p4, descr=strequaldescr)
         escape(i0)
         jump(p1, p2)
         """
@@ -4630,7 +4630,7 @@
         p4 = newstr(i3)
         copystrcontent(p1, p4, 0, 0, i1)
         copystrcontent(p2, p4, 0, i1, i2)
-        i0 = call(0, s"hello world", p4, descr=streq_nonnull_descr)
+        i0 = call_i(0, s"hello world", p4, descr=streq_nonnull_descr)
         escape(i0)
         jump(p1, p2)
         """
@@ -4640,7 +4640,7 @@
         ops = """
         [i1]
         p1 = newstr(0)
-        i0 = call(0, p1, s"", descr=strequaldescr)
+        i0 = call_i(0, p1, s"", descr=strequaldescr)
         escape(i0)
         jump(i1)
         """
@@ -4656,7 +4656,7 @@
         [i1]
         p1 = newstr(1)
         strsetitem(p1, 0, i1)
-        i0 = call(0, p1, s"x", descr=strequaldescr)
+        i0 = call_i(0, p1, s"x", descr=strequaldescr)
         escape(i0)
         jump(i1)
         """
@@ -4674,7 +4674,7 @@
         p1 = newstr(2)
         strsetitem(p1, 0, i1)
         strsetitem(p1, 1, i2)
-        i0 = call(0, p1, s"xy", descr=strequaldescr)
+        i0 = call_i(0, p1, s"xy", descr=strequaldescr)
         escape(i0)
         jump(i1, i2)
         """
@@ -4683,7 +4683,7 @@
         p1 = newstr(2)
         strsetitem(p1, 0, i1)
         strsetitem(p1, 1, i2)
-        i0 = call(0, p1, s"xy", descr=streq_lengthok_descr)
+        i0 = call_i(0, p1, s"xy", descr=streq_lengthok_descr)
         escape(i0)
         jump(i1, i2)
         """
@@ -4692,13 +4692,13 @@
     def test_str_equal_chars3(self):
         ops = """
         [p1]
-        i0 = call(0, s"x", p1, descr=strequaldescr)
+        i0 = call_i(0, s"x", p1, descr=strequaldescr)
         escape(i0)
         jump(p1)
         """
         expected = """
         [p1]
-        i0 = call(0, p1, 120, descr=streq_checknull_char_descr)
+        i0 = call_i(0, p1, 120, descr=streq_checknull_char_descr)
         escape(i0)
         jump(p1)
         """
@@ -4709,7 +4709,7 @@
         [i1]
         p1 = newstr(1)
         strsetitem(p1, 0, i1)
-        i0 = call(0, s"xy", p1, descr=strequaldescr)
+        i0 = call_i(0, s"xy", p1, descr=strequaldescr)
         escape(i0)
         jump(i1)
         """
@@ -4723,7 +4723,7 @@
     def test_str2unicode_constant(self):
         ops = """
         []
-        p0 = call(0, "xy", descr=s2u_descr)      # string -> unicode
+        p0 = call_r(0, "xy", descr=s2u_descr)      # string -> unicode
         escape(p0)
         jump()
         """
@@ -4737,7 +4737,7 @@
     def test_str2unicode_nonconstant(self):
         ops = """
         [p0]
-        p1 = call(0, p0, descr=s2u_descr)      # string -> unicode
+        p1 = call_r(0, p0, descr=s2u_descr)      # string -> unicode
         escape(p1)
         jump(p1)
         """
@@ -4787,7 +4787,7 @@
         ops = """
         [p0, i0]
         i1 = int_add(i0, 1)
-        p1 = call(0, p0, i0, i1, descr=strslicedescr)
+        p1 = call_r(0, p0, i0, i1, descr=strslicedescr)
         escape(p1)
         jump(p0, i1)
         """
@@ -4956,10 +4956,10 @@
         [p0, i0]
         i1 = int_gt(i0, 2)
         guard_true(i1) []
-        setarrayitem_gc(p0, 0, 3)
-        setarrayitem_gc(p0, 2, 4)
-        setarrayitem_gc(p0, i0, 15)
-        i2 = getarrayitem_gc(p0, 2)
+        setarrayitem_gc(p0, 0, 3, descr=arraydescr)
+        setarrayitem_gc(p0, 2, 4, descr=arraydescr)
+        setarrayitem_gc(p0, i0, 15, descr=arraydescr)
+        i2 = getarrayitem_gc_i(p0, 2, descr=arraydescr)
         jump(p0, i2)
         """
         # Remove the getarrayitem_gc, because we know that p[i0] does not alias
@@ -4968,9 +4968,9 @@
         [p0, i0]
         i1 = int_gt(i0, 2)
         guard_true(i1) []
-        setarrayitem_gc(p0, i0, 15)
-        setarrayitem_gc(p0, 0, 3)
-        setarrayitem_gc(p0, 2, 4)
+        setarrayitem_gc(p0, i0, 15, descr=arraydescr)
+        setarrayitem_gc(p0, 0, 3, descr=arraydescr)
+        setarrayitem_gc(p0, 2, 4, descr=arraydescr)
         jump(p0, 4)
         """
         self.optimize_loop(ops, expected)
@@ -5036,7 +5036,7 @@
         [i1]
         p0 = newstr(6)
         copystrcontent(s"hello!", p0, 0, 0, 6)
-        p1 = call(0, p0, s"abc123", descr=strconcatdescr)
+        p1 = call_r(0, p0, s"abc123", descr=strconcatdescr)
         i0 = strgetitem(p1, i1)
         finish(i0)
         """
@@ -5052,7 +5052,7 @@
         []
         p0 = newstr(6)
         copystrcontent(s"hello!", p0, 0, 0, 6)
-        p1 = call(0, p0, s"abc123", descr=strconcatdescr)
+        p1 = call_r(0, p0, s"abc123", descr=strconcatdescr)
         i0 = strgetitem(p1, 0)
         finish(i0)
         """
diff --git a/rpython/jit/metainterp/optimizeopt/virtualize.py b/rpython/jit/metainterp/optimizeopt/virtualize.py
--- a/rpython/jit/metainterp/optimizeopt/virtualize.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualize.py
@@ -568,7 +568,9 @@
         if self._last_guard_not_forced_2 is not None:
             guard_op = self._last_guard_not_forced_2
             self.emit_operation(op)
-            guard_op = self.optimizer.store_final_boxes_in_guard(guard_op, [])
+            v = self.getvalue(op)
+            guard_op = self.optimizer.store_final_boxes_in_guard(guard_op, [],
+                                                                 v)
             i = len(self.optimizer._newoperations) - 1
             assert i >= 0
             self.optimizer._newoperations.insert(i, guard_op)
diff --git a/rpython/jit/metainterp/optimizeopt/vstring.py b/rpython/jit/metainterp/optimizeopt/vstring.py
--- a/rpython/jit/metainterp/optimizeopt/vstring.py
+++ b/rpython/jit/metainterp/optimizeopt/vstring.py
@@ -5,7 +5,7 @@
 from rpython.jit.metainterp.optimizeopt.optimizer import CONST_0, CONST_1
 from rpython.jit.metainterp.optimizeopt.optimizer import llhelper, REMOVED
 from rpython.jit.metainterp.optimizeopt.util import make_dispatcher_method
-from rpython.jit.metainterp.resoperation import rop, ResOperation
+from rpython.jit.metainterp.resoperation import rop, ResOperation, DONT_CHANGE
 from rpython.rlib.objectmodel import specialize, we_are_translated
 from rpython.rlib.unroll import unrolling_iterable
 from rpython.rtyper import annlowlevel
@@ -61,11 +61,12 @@
             return None
         self.ensure_nonnull()
         box = self.force_box(string_optimizer)
-        if lengthop is None:
-            xxx
-        else:
+        if lengthop is not None:
             lengthop = string_optimizer.optimizer.replace_op_with(lengthop,
                 mode.STRLEN, [box])
+        else:
+            lengthop = ResOperation(mode.STRLEN, [box])
+            lengthop.is_source_op = True
         string_optimizer.emit_operation(lengthop)
         return lengthop
 
@@ -90,9 +91,8 @@
 class VAbstractStringValue(virtualize.AbstractVirtualValue):
     _attrs_ = ('mode',)
 
-    def __init__(self, keybox, source_op, mode):
-        virtualize.AbstractVirtualValue.__init__(self, keybox,
-                                                 source_op)
+    def __init__(self, source_op, mode):
+        virtualize.AbstractVirtualValue.__init__(self, source_op)
         self.mode = mode
 
     def _really_force(self, optforce):
@@ -109,13 +109,14 @@
                 self.make_constant(c_s)
                 return
         assert self.source_op is not None
-        self.box = box = self.source_op.result
         lengthbox = self.getstrlen(optforce, self.mode, None)
-        op = ResOperation(self.mode.NEWSTR, [lengthbox], box)
+        op = ResOperation(self.mode.NEWSTR, [lengthbox])
+        op.source_op = self.source_op
+        self.box = op
         if not we_are_translated():
             op.name = 'FORCE'
         optforce.emit_operation(op)
-        self.initialize_forced_string(optforce, box, CONST_0, self.mode)
+        self.initialize_forced_string(optforce, self.box, CONST_0, self.mode)
 
     def initialize_forced_string(self, string_optimizer, targetbox,
                                  offsetbox, mode):
@@ -188,7 +189,7 @@
     def initialize_forced_string(self, string_optimizer, targetbox,
                                  offsetbox, mode):
         for i in range(len(self._chars)):
-            assert isinstance(targetbox, BoxPtr)   # ConstPtr never makes sense
+            assert not isinstance(targetbox, Const) # ConstPtr never makes sense
             charvalue = self.getitem(i)
             if charvalue is not None:
                 charbox = charvalue.force_box(string_optimizer)
@@ -281,7 +282,6 @@
         self.vlength = vlength
 
     def getstrlen(self, optforce, mode, lengthbox):
-        xxx
         return self.vlength.force_box(optforce)
 
     @specialize.arg(1)
@@ -330,7 +330,7 @@
         for i in range(lengthbox.value):
             charbox = _strgetitem(string_optimizer, srcbox, srcoffsetbox, mode)
             srcoffsetbox = _int_add(string_optimizer, srcoffsetbox, CONST_1)
-            assert isinstance(targetbox, BoxPtr)   # ConstPtr never makes sense
+            assert not isinstance(targetbox, Const)# ConstPtr never makes sense
             string_optimizer.emit_operation(ResOperation(mode.STRSETITEM, [targetbox,
                                                                            offsetbox,
                                                                            charbox],
@@ -341,10 +341,10 @@
             nextoffsetbox = _int_add(string_optimizer, offsetbox, lengthbox)
         else:
             nextoffsetbox = None
-        assert isinstance(targetbox, BoxPtr)   # ConstPtr never makes sense
+        assert not isinstance(targetbox, Const)   # ConstPtr never makes sense
         op = ResOperation(mode.COPYSTRCONTENT, [srcbox, targetbox,
                                                 srcoffsetbox, offsetbox,
-                                                lengthbox], None)
+                                                lengthbox])
         string_optimizer.emit_operation(op)
         offsetbox = nextoffsetbox
     return offsetbox
@@ -359,9 +359,10 @@
         return box1
     if string_optimizer is None:
         return None
-    resbox = BoxInt()
-    string_optimizer.emit_operation(ResOperation(rop.INT_ADD, [box1, box2], resbox))
-    return resbox
+    op = ResOperation(rop.INT_ADD, [box1, box2])
+    op.is_source_op = True
+    string_optimizer.emit_operation(op)
+    return op
 
 def _int_sub(string_optimizer, box1, box2):
     if isinstance(box2, ConstInt):
@@ -369,9 +370,10 @@
             return box1
         if isinstance(box1, ConstInt):
             return ConstInt(box1.value - box2.value)
-    resbox = BoxInt()
-    string_optimizer.emit_operation(ResOperation(rop.INT_SUB, [box1, box2], resbox))
-    return resbox
+    op = ResOperation(rop.INT_SUB, [box1, box2])
+    op.is_source_op = True
+    string_optimizer.emit_operation(op)
+    return op
 
 def _strgetitem(string_optimizer, strbox, indexbox, mode, resbox=None):
     if isinstance(strbox, ConstPtr) and isinstance(indexbox, ConstInt):
@@ -382,28 +384,30 @@
             s = strbox.getref(lltype.Ptr(rstr.UNICODE))
             return ConstInt(ord(s.chars[indexbox.getint()]))
     if resbox is None:
-        resbox = BoxInt()
-    string_optimizer.emit_operation(ResOperation(mode.STRGETITEM, [strbox, indexbox],
-                                                 resbox))
+        resbox = ResOperation(mode.STRGETITEM, [strbox, indexbox])
+    else:
+        resbox = string_optimizer.replace_op_with(resbox, mode.STRGETITEM,
+                                                  [strbox, indexbox])
+    string_optimizer.emit_operation(resbox)
     return resbox
 
 
 class OptString(optimizer.Optimization):
     "Handling of strings and unicodes."
 
-    def make_vstring_plain(self, box, source_op, mode):
-        vvalue = VStringPlainValue(box, source_op, mode)
-        self.make_equal_to(box, vvalue)
+    def make_vstring_plain(self, source_op, mode):
+        vvalue = VStringPlainValue(source_op, mode)
+        self.make_equal_to(source_op, vvalue)
         return vvalue
 
-    def make_vstring_concat(self, box, source_op, mode):
-        vvalue = VStringConcatValue(box, source_op, mode)
-        self.make_equal_to(box, vvalue)
+    def make_vstring_concat(self, source_op, mode):
+        vvalue = VStringConcatValue(source_op, mode)
+        self.make_equal_to(source_op, vvalue)
         return vvalue
 
-    def make_vstring_slice(self, box, source_op, mode):
-        vvalue = VStringSliceValue(box, source_op, mode)
-        self.make_equal_to(box, vvalue)
+    def make_vstring_slice(self, source_op, mode):
+        vvalue = VStringSliceValue(source_op, mode)
+        self.make_equal_to(source_op, vvalue)
         return vvalue
 
     def optimize_NEWSTR(self, op):
@@ -417,13 +421,13 @@
             # if the original 'op' did not have a ConstInt as argument,
             # build a new one with the ConstInt argument
             if not isinstance(op.getarg(0), ConstInt):
-                op = ResOperation(mode.NEWSTR, [length_box], op.result)
-            vvalue = self.make_vstring_plain(op.result, op, mode)
+                op = self.replace_op_with(op, mode.NEWSTR, [length_box])
+            vvalue = self.make_vstring_plain(op, mode)
             vvalue.setup(length_box.getint())
         else:
-            self.getvalue(op.result).ensure_nonnull()
+            self.getvalue(op).ensure_nonnull()
             self.emit_operation(op)
-            self.pure(mode.STRLEN, [op.result], op.getarg(0))
+            self.pure(mode.STRLEN, [op], op.getarg(0))
 
     def optimize_STRSETITEM(self, op):
         value = self.getvalue(op.getarg(0))
@@ -446,11 +450,11 @@
     def _optimize_STRGETITEM(self, op, mode):
         value = self.getvalue(op.getarg(0))
         vindex = self.getvalue(op.getarg(1))
-        vresult = self.strgetitem(value, vindex, mode, op.result)
-        if op.result in self.optimizer.values:
-            assert self.getvalue(op.result) is vresult
+        vresult = self.strgetitem(value, vindex, mode, op)
+        if op in self.optimizer.values:
+            assert self.getvalue(op) is vresult
         else:
-            self.make_equal_to(op.result, vresult)
+            self.make_equal_to(op, vresult)
 
     def strgetitem(self, value, vindex, mode, resbox=None):
         value.ensure_nonnull()
@@ -595,7 +599,7 @@
             u = unicode(s)
         except UnicodeDecodeError:
             return False
-        self.make_constant(op.result, get_const_ptr_for_unicode(u))
+        self.make_constant(op, get_const_ptr_for_unicode(u))
         self.last_emitted_operation = REMOVED
         return True
 
@@ -604,7 +608,7 @@
         vright = self.getvalue(op.getarg(2))
         vleft.ensure_nonnull()
         vright.ensure_nonnull()
-        value = self.make_vstring_concat(op.result, op, mode)
+        value = self.make_vstring_concat(op, mode)
         value.setup(vleft, vright)
         return True
 
@@ -633,7 +637,7 @@
                                 vstart.force_box(self))
             vstart = self.getvalue(startbox)
         #
-        value = self.make_vstring_slice(op.result, op, mode)
+        value = self.make_vstring_slice(op, mode)
         value.setup(vstr, vstart, self.getvalue(lengthbox))
         return True
 
@@ -648,16 +652,16 @@
             isinstance(l2box, ConstInt) and
             l1box.value != l2box.value):
             # statically known to have a different length
-            self.make_constant(op.result, CONST_0)
+            self.make_constant(op, CONST_0)
             return True
         #
-        if self.handle_str_equal_level1(v1, v2, op.result, mode):
+        if self.handle_str_equal_level1(v1, v2, op, mode):
             return True
-        if self.handle_str_equal_level1(v2, v1, op.result, mode):
+        if self.handle_str_equal_level1(v2, v1, op, mode):
             return True
-        if self.handle_str_equal_level2(v1, v2, op.result, mode):
+        if self.handle_str_equal_level2(v1, v2, op, mode):
             return True
-        if self.handle_str_equal_level2(v2, v1, op.result, mode):
+        if self.handle_str_equal_level2(v2, v1, op, mode):
             return True
         #
         if v1.is_nonnull() and v2.is_nonnull():
@@ -666,17 +670,20 @@
             else:
                 do = EffectInfo.OS_STREQ_NONNULL
             self.generate_modified_call(do, [v1.force_box(self),
-                                             v2.force_box(self)], op.result, mode)
+                                             v2.force_box(self)], op, mode)
             return True
         return False
 
-    def handle_str_equal_level1(self, v1, v2, resultbox, mode):
+    def handle_str_equal_level1(self, v1, v2, resultop, mode):
         l2box = v2.getstrlen(None, mode, None)
         if isinstance(l2box, ConstInt):
             if l2box.value == 0:
                 lengthbox = v1.getstrlen(self, mode, None)
                 seo = self.optimizer.send_extra_operation
-                seo(ResOperation(rop.INT_EQ, [lengthbox, CONST_0], resultbox))
+                op = self.replace_op_with(resultop, rop.INT_EQ,
+                                          [lengthbox, CONST_0],
+                                          descr=DONT_CHANGE)
+                seo(op)
                 return True
             if l2box.value == 1:
                 l1box = v1.getstrlen(None, mode, None)
@@ -685,9 +692,10 @@
                     vchar1 = self.strgetitem(v1, optimizer.CVAL_ZERO, mode)
                     vchar2 = self.strgetitem(v2, optimizer.CVAL_ZERO, mode)
                     seo = self.optimizer.send_extra_operation
-                    seo(ResOperation(rop.INT_EQ, [vchar1.force_box(self),
-                                                  vchar2.force_box(self)],
-                                     resultbox))
+                    op = self.optimizer.replace_op_with(resultop, rop.INT_EQ,
+                          [vchar1.force_box(self), vchar2.force_box(self)],
+                        descr=DONT_CHANGE)
+                    seo(op)
                     return True
                 if isinstance(v1, VStringSliceValue):
                     vchar = self.strgetitem(v2, optimizer.CVAL_ZERO, mode)
@@ -696,19 +704,20 @@
                                                      v1.vstart.force_box(self),
                                                      v1.vlength.force_box(self),
                                                      vchar.force_box(self)],
-                                                resultbox, mode)
+                                                     resultop, mode)
                     return True
         #
         if v2.is_null():
             if v1.is_nonnull():
-                self.make_constant(resultbox, CONST_0)
+                self.make_constant(resultop, CONST_0)
                 return True
             if v1.is_null():
-                self.make_constant(resultbox, CONST_1)
+                self.make_constant(resultop, CONST_1)
                 return True
-            op = ResOperation(rop.PTR_EQ, [v1.force_box(self),
-                                           llhelper.CONST_NULL],
-                              resultbox)
+            op = self.optimizer.replace_op_with(resultop, rop.PTR_EQ,
+                                                [v1.force_box(self),
+                                                 llhelper.CONST_NULL],
+                descr=DONT_CHANGE)
             self.emit_operation(op)
             return True
         #
@@ -776,8 +785,9 @@
         oopspecindex += mode.OS_offset
         cic = self.optimizer.metainterp_sd.callinfocollection
         calldescr, func = cic.callinfo_for_oopspec(oopspecindex)
-        op = ResOperation(rop.CALL, [ConstInt(func)] + args, result,
-                          descr=calldescr)
+        op = self.optimizer.replace_op_with(result, rop.CALL_I,
+                                            [ConstInt(func)] + args,
+                                            descr=calldescr)
         self.emit_operation(op)
 
     def propagate_forward(self, op):
diff --git a/rpython/jit/metainterp/quasiimmut.py b/rpython/jit/metainterp/quasiimmut.py
--- a/rpython/jit/metainterp/quasiimmut.py
+++ b/rpython/jit/metainterp/quasiimmut.py
@@ -120,12 +120,12 @@
             return ConstInt(self.cpu.bh_getfield_gc_i(struct, fielddescr))
 
     def is_still_valid_for(self, structconst):
-        assert self.structbox is not None
-        if not self.structbox.constbox().same_constant(structconst):
+        assert self.struct
+        if self.struct != structconst.getref_base():
             return False
         cpu = self.cpu
-        gcref = self.structbox.getref_base()
-        qmut = get_current_qmut_instance(cpu, gcref, self.mutatefielddescr)
+        qmut = get_current_qmut_instance(cpu, self.struct,
+                                         self.mutatefielddescr)
         if qmut is not self.qmut:
             return False
         else:
diff --git a/rpython/jit/metainterp/resoperation.py b/rpython/jit/metainterp/resoperation.py
--- a/rpython/jit/metainterp/resoperation.py
+++ b/rpython/jit/metainterp/resoperation.py
@@ -13,6 +13,8 @@
     def repr_short(self, memo):
         return self.repr(memo)
 
+DONT_CHANGE = AbstractValue()
+
 def ResOperation(opnum, args, descr=None):
     cls = opclasses[opnum]
     op = cls()
@@ -96,6 +98,8 @@
             args = self.getarglist()
         if descr is None:
             descr = self.getdescr()
+        if descr is DONT_CHANGE:
+            descr = None
         newop = ResOperation(opnum, args, descr)
         if self.type != 'v':
             newop.copy_value_from(self)


More information about the pypy-commit mailing list