[pypy-svn] pypy arm-backend-2: Improve freeing of boxes and also free the failargs of guards

[bivab]

Author: David Schneider <david.schneider at picle.org>
Branch: arm-backend-2
Changeset: r42135:f10a4fc7e222
Date: 2011-02-17 21:00 +0100
http://bitbucket.org/pypy/pypy/changeset/f10a4fc7e222/

Log:	Improve freeing of boxes and also free the failargs of guards

diff --git a/pypy/jit/backend/arm/opassembler.py b/pypy/jit/backend/arm/opassembler.py
--- a/pypy/jit/backend/arm/opassembler.py
+++ b/pypy/jit/backend/arm/opassembler.py
@@ -297,11 +297,10 @@
             self._adjust_sp(-n, fcond=fcond)
 
         # restore the argumets stored on the stack
-        if spill_all_regs:
+        if result is not None:
             regalloc.after_call(result)
-        else:
+        if not spill_all_regs:
             if result is not None:
-                regalloc.after_call(result)
                 self.mc.POP([reg.value for reg in r.caller_resp][1:])
             else:
                 self.mc.POP([reg.value for reg in r.caller_resp])
@@ -678,7 +677,7 @@
         assert resloc is r.r0
         self.mc.gen_load_int(r.ip.value, value)
         self.mc.CMP_rr(resloc.value, r.ip.value)
-
+        regalloc.possibly_free_var(resbox)
 
         fast_jmp_pos = self.mc.currpos()
         self.mc.NOP()
@@ -695,7 +694,8 @@
         self.mov_loc_loc(arglocs[1], r.r1)
         self.mc.BL(asm_helper_adr)
         self.mc.POP([reg.value for reg in r.caller_resp][1:])
-        regalloc.after_call(op.result)
+        if op.result:
+            regalloc.after_call(op.result)
         # jump to merge point
         jmp_pos = self.mc.currpos()
         #jmp_location = self.mc.curraddr()
@@ -715,10 +715,11 @@
             fielddescr = jd.vable_token_descr
             assert isinstance(fielddescr, BaseFieldDescr)
             ofs = fielddescr.offset
+            resloc = regalloc.force_allocate_reg(resbox)
             self.mov_loc_loc(arglocs[1], r.ip, cond=c.MI)
             self.mc.MOV_ri(resloc.value, 0, cond=c.MI)
             self.mc.STR_ri(resloc.value, r.ip.value, ofs*WORD, cond=c.MI)
-        regalloc.possibly_free_var(resbox)
+            regalloc.possibly_free_var(resbox)
 
         if op.result is not None:
             # load the return value from fail_boxes_xxx[0]

diff --git a/pypy/jit/backend/arm/regalloc.py b/pypy/jit/backend/arm/regalloc.py
--- a/pypy/jit/backend/arm/regalloc.py
+++ b/pypy/jit/backend/arm/regalloc.py
@@ -211,6 +211,7 @@
         args = self._prepare_guard(guard, args)
         self.possibly_free_vars(boxes)
         self.possibly_free_var(op.result)
+        self.possibly_free_vars(guard.getfailargs())
         return args
 
 
@@ -277,6 +278,7 @@
             arg = op.getarg(i)
             if arg:
                 args.append(self.loc(arg))
+                self.possibly_free_var(arg)
             else:
                 args.append(None)
         return args
@@ -285,6 +287,7 @@
         l0, box = self._ensure_value_is_boxed(op.getarg(0))
         args = self._prepare_guard(op, [l0])
         self.possibly_free_var(box)
+        self.possibly_free_vars(op.getfailargs())
         return args
 
     prepare_op_guard_false = prepare_op_guard_true
@@ -305,10 +308,13 @@
         assert op.result is None
         arglocs = self._prepare_guard(op, [l0, l1])
         self.possibly_free_vars(boxes)
+        self.possibly_free_vars(op.getfailargs())
         return arglocs
 
     def prepare_op_guard_no_overflow(self, op, fcond):
-        return  self._prepare_guard(op)
+        locs = self._prepare_guard(op)
+        self.possibly_free_vars(op.getfailargs())
+        return locs
 
     prepare_op_guard_overflow = prepare_op_guard_no_overflow
 
@@ -329,6 +335,7 @@
         pos_exception = imm(self.cpu.pos_exception())
         arglocs = self._prepare_guard(op, [loc, loc1, resloc, pos_exc_value, pos_exception])
         self.possibly_free_vars(boxes)
+        self.possibly_free_vars(op.getfailargs())
         return arglocs
 
     def prepare_op_guard_no_exception(self, op, fcond):
@@ -336,6 +343,7 @@
                     ConstInt(self.cpu.pos_exception()))
         arglocs = self._prepare_guard(op, [loc])
         self.possibly_free_var(box)
+        self.possibly_free_vars(op.getfailargs())
         return arglocs
 
     def prepare_op_guard_class(self, op, fcond):
@@ -361,6 +369,7 @@
         boxes.append(offset_box)
         arglocs = self._prepare_guard(op, [x, y, offset_loc])
         self.possibly_free_vars(boxes)
+        self.possibly_free_vars(op.getfailargs())
 
         return arglocs
 
@@ -368,7 +377,8 @@
     def prepare_op_jump(self, op, fcond):
         descr = op.getdescr()
         assert isinstance(descr, LoopToken)
-        return [self.loc(op.getarg(i)) for i in range(op.numargs())]
+        locs = [self.loc(op.getarg(i)) for i in range(op.numargs())]
+        return locs
 
 
     def prepare_op_setfield_gc(self, op, fcond):
@@ -577,7 +587,6 @@
         else:
             argloc, box = self._ensure_value_is_boxed(arg)
             self.possibly_free_var(box)
-        self.possibly_free_vars_for_op(op)
 
         resloc = self.force_allocate_reg(op.result)
         self.possibly_free_var(op.result)
@@ -672,7 +681,9 @@
         # force all reg values to be spilled when calling
         self.assembler.emit_op_call(op, args, self, fcond, spill_all_regs=True)
 
-        return self._prepare_guard(guard_op)
+        locs = self._prepare_guard(guard_op)
+        self.possibly_free_vars(guard_op.getfailargs())
+        return locs
 
     def prepare_guard_call_assembler(self, op, guard_op, fcond):
         descr = op.getdescr()
@@ -686,6 +697,7 @@
             vable = self.frame_manager.loc(op.getarg(vable_index))
         else:
             vable = imm(0)
+        self.possibly_free_vars(guard_op.getfailargs())
         return [imm(size), vable]
 
     def _prepare_args_for_new_op(self, new_args):