[pypy-svn] r63591 - pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86
fijal at codespeak.net
fijal at codespeak.net
Sat Apr 4 00:28:42 CEST 2009
Author: fijal
Date: Sat Apr 4 00:28:40 2009
New Revision: 63591
Modified:
pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/assembler.py
pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/regalloc.py
Log:
progress. Implement guard_no_exception and minor fixes
Modified: pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/assembler.py
==============================================================================
--- pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/assembler.py (original)
+++ pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/assembler.py Sat Apr 4 00:28:40 2009
@@ -184,9 +184,19 @@
if not we_are_translated():
self._regalloc = regalloc # for debugging
regalloc.walk_operations(tree)
+ self.sanitize_tree(tree.operations)
self.mc.done()
self.mc2.done()
+ def sanitize_tree(self, operations):
+ """ Cleans up all attributes attached by regalloc and backend
+ """
+ for op in operations:
+ if op.is_guard():
+ op.inputargs = None
+ op.longevity = None
+ self.sanitize_tree(op.suboperations)
+
def assemble_bootstrap_code(self, arglocs):
self.make_sure_mc_exists()
addr = self.mc.tell()
@@ -254,7 +264,13 @@
def regalloc_perform_with_guard(self, op, guard_op, regalloc,
arglocs, resloc):
addr = self.implement_guard_recovery(guard_op, regalloc)
- genop_guard_list[op.opnum](self, op, addr, guard_op, arglocs, resloc)
+ genop_guard_list[op.opnum](self, op, addr, guard_op, arglocs,
+ resloc)
+
+ def regalloc_perform_guard(self, op, regalloc, arglocs, resloc):
+ addr = self.implement_guard_recovery(op, regalloc)
+ genop_guard_list[op.opnum](self, op, addr, None, arglocs,
+ resloc)
def _unaryop(asmop):
def genop_unary(self, op, arglocs, resloc):
@@ -552,16 +568,16 @@
targetmp = op.jump_target
self.mc.JMP(rel32(targetmp.position))
- def genop_discard_guard_true(self, op, locs):
+ def genop_guard_guard_true(self, op, addr, ign_1, locs, ign_2):
loc = locs[0]
self.mc.TEST(loc, loc)
- self.implement_guard(op, self.mc.JZ, locs[1:])
+ self.implement_guard(addr, op, self.mc.JZ)
- def genop_discard_guard_no_exception(self, op, locs):
+ def genop_guard_guard_no_exception(self, op, addr, ign_1, locs, ign_2):
loc = locs[0]
self.mc.MOV(loc, heap(self._exception_addr))
self.mc.TEST(loc, loc)
- self.implement_guard(op, self.mc.JNZ, locs[1:])
+ self.implement_guard(addr, op, self.mc.JNZ)
def genop_guard_exception(self, op, locs, resloc):
loc = locs[0]
Modified: pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/regalloc.py
==============================================================================
--- pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/regalloc.py (original)
+++ pypy/branch/pyjitpl5-simplify/pypy/jit/backend/x86/regalloc.py Sat Apr 4 00:28:40 2009
@@ -83,10 +83,16 @@
self.free_regs = [v for v in REGS if v not in allocated_regs]
self.loop_consts = regalloc.loop_consts # should never change
self.current_stack_depth = regalloc.current_stack_depth
- # XXX think what to do if there is actually a jump
- self.jump_reg_candidates = {}
self.longevity = guard_op.longevity
- #self.jump_reg_candidates = regalloc.jump_reg_candidates
+ jump_or_fail = guard_op.suboperations[-1]
+ if jump_or_fail.opnum == rop.FAIL:
+ self.jump_reg_candidates = {}
+ else:
+ self._create_jump_reg_candidates(jump_or_fail.jump_target)
+
+ def _create_jump_reg_candidates(self, jump_target):
+ # XXX improve
+ self.jump_reg_candidates = {}
def copy(self, guard_op):
return RegAlloc(self.assembler, None, self.translate_support_code,
@@ -200,6 +206,14 @@
self.assembler.regalloc_perform_with_guard(op, guard_op, regalloc,
arglocs, result_loc)
+ def perform_guard(self, op, regalloc, arglocs, result_loc):
+ if not we_are_translated():
+ if result_loc is not None:
+ self.assembler.dump('%s <- %s(%s)' % (result_loc, op, arglocs))
+ else:
+ self.assembler.dump('%s(%s)' % (op, arglocs))
+ self.assembler.regalloc_perform_guard(op, regalloc, arglocs, result_loc)
+
def PerformDiscard(self, op, arglocs):
if not we_are_translated():
self.assembler.dump('%s(%s)' % (op, arglocs))
@@ -283,7 +297,7 @@
for i in range(len(operations)-1, -1, -1):
op = operations[i]
if op.is_guard():
- self._compute_inpargs()
+ self._compute_inpargs(op)
for arg in op.inputargs:
if isinstance(arg, Box) and arg not in end:
end[arg] = i
@@ -388,20 +402,20 @@
self.Store(v_to_spill, loc, newloc)
return loc
- def _locs_from_liveboxes(self, guard_op):
- stacklocs = []
- locs = []
- for arg in guard_op.inputargs:
- assert isinstance(arg, Box)
- if arg not in self.stack_bindings:
- self.dirty_stack[arg] = True
- stacklocs.append(self.stack_loc(arg).position)
- locs.append(self.loc(arg))
- if not we_are_translated():
- assert len(dict.fromkeys(stacklocs)) == len(stacklocs)
- guard_op.stacklocs = stacklocs
- guard_op.locs = locs
- return locs
+# def _locs_from_liveboxes(self, guard_op):
+# stacklocs = []
+# locs = []
+# for arg in guard_op.inputargs:
+# assert isinstance(arg, Box)
+# if arg not in self.stack_bindings:
+# self.dirty_stack[arg] = True
+# stacklocs.append(self.stack_loc(arg).position)
+# locs.append(self.loc(arg))
+# if not we_are_translated():
+# assert len(dict.fromkeys(stacklocs)) == len(stacklocs)
+# guard_op.stacklocs = stacklocs
+# guard_op.locs = locs
+# return locs
def stack_loc(self, v):
try:
@@ -545,13 +559,19 @@
# XXX be a bit smarter and completely ignore such vars
self.eventually_free_vars(inputargs)
+ def regalloc_for_guard(self, guard_op):
+ regalloc = self.copy(guard_op)
+ fop = guard_op.suboperations[-1]
+ if fop.opnum == rop.FAIL:
+ regalloc.guard_index = self.assembler.cpu.make_guard_index(fop)
+ return regalloc
+
def _consider_guard(self, op, ignored):
loc = self.make_sure_var_in_reg(op.args[0], [])
- locs = self._locs_from_liveboxes(op)
- xxx
+ regalloc = self.regalloc_for_guard(op)
+ self.perform_guard(op, regalloc, [loc], None)
self.eventually_free_var(op.args[0])
- self.eventually_free_vars(op.liveboxes)
- self.PerformDiscard(op, [loc] + locs)
+ self.eventually_free_vars(op.inputargs)
consider_guard_true = _consider_guard
consider_guard_false = _consider_guard
@@ -571,10 +591,10 @@
def consider_guard_no_exception(self, op, ignored):
box = TempBox()
loc = self.force_allocate_reg(box, [])
- locs = self._locs_from_liveboxes(op)
- self.eventually_free_vars(op.liveboxes)
+ regalloc = self.regalloc_for_guard(op)
+ self.eventually_free_vars(op.inputargs)
self.eventually_free_var(box)
- self.PerformDiscard(op, [loc] + locs)
+ self.perform_guard(op, regalloc, [loc], None)
def consider_guard_exception(self, op, ignored):
loc = self.make_sure_var_in_reg(op.args[0], [])
@@ -729,14 +749,9 @@
loc = self.force_allocate_reg(op.result, op.args)
self.Perform(op, arglocs, loc)
else:
- regalloc = self.copy(guard_op)
- fop = guard_op.suboperations[-1]
- assert fop.opnum == rop.FAIL # XXX also JUMP
- regalloc.guard_index = self.assembler.cpu.make_guard_index(fop)
- locs = self._locs_from_liveboxes(guard_op)
+ regalloc = self.regalloc_for_guard(guard_op)
self.position += 1
- self.perform_with_guard(op, guard_op, regalloc, arglocs + locs,
- None)
+ self.perform_with_guard(op, guard_op, regalloc, arglocs, None)
self.eventually_free_var(op.result)
self.eventually_free_vars(guard_op.inputargs)
More information about the Pypy-commit
mailing list