Author: hager <sven.ha...@uni-duesseldorf.de> Branch: ppc-jit-backend Changeset: r51012:96c640b286a3 Date: 2012-01-04 14:58 +0100 http://bitbucket.org/pypy/pypy/changeset/96c640b286a3/
Log: (bivab, hager): adjust implementation of JUMP, implement LABEL diff --git a/pypy/jit/backend/ppc/ppcgen/opassembler.py b/pypy/jit/backend/ppc/ppcgen/opassembler.py --- a/pypy/jit/backend/ppc/ppcgen/opassembler.py +++ b/pypy/jit/backend/ppc/ppcgen/opassembler.py @@ -321,16 +321,21 @@ self._gen_epilogue(self.mc) def emit_jump(self, op, arglocs, regalloc): + # The backend's logic assumes that the target code is in a piece of + # assembler that was also called with the same number of arguments, + # so that the locations [ebp+8..] of the input arguments are valid + # stack locations both before and after the jump. + # descr = op.getdescr() - assert isinstance(descr, LoopToken) - if descr._ppc_bootstrap_code == 0: + assert isinstance(descr, TargetToken) + my_nbargs = self.current_clt._debug_nbargs + target_nbargs = descr._ppc_clt._debug_nbargs + assert my_nbargs == target_nbargs + + if descr in self.target_tokens_currently_compiling: self.mc.b_offset(descr._ppc_loop_code) else: - target = descr._ppc_bootstrap_code + descr._ppc_loop_code - self.mc.b_abs(target) - new_fd = max(regalloc.frame_manager.frame_depth, - descr._ppc_frame_manager_depth) - regalloc.frame_manager.frame_depth = new_fd + self.mc.b_abs(descr._ppc_loop_code) def emit_same_as(self, op, arglocs, regalloc): argloc, resloc = arglocs diff --git a/pypy/jit/backend/ppc/ppcgen/regalloc.py b/pypy/jit/backend/ppc/ppcgen/regalloc.py --- a/pypy/jit/backend/ppc/ppcgen/regalloc.py +++ b/pypy/jit/backend/ppc/ppcgen/regalloc.py @@ -1,7 +1,8 @@ from pypy.jit.backend.llsupport.regalloc import (RegisterManager, FrameManager, TempBox, compute_vars_longevity) from pypy.jit.backend.ppc.ppcgen.arch import (WORD, MY_COPY_OF_REGS) -from pypy.jit.backend.ppc.ppcgen.jump import remap_frame_layout_mixed +from pypy.jit.backend.ppc.ppcgen.jump import (remap_frame_layout_mixed, + remap_frame_layout) from pypy.jit.backend.ppc.ppcgen.locations import imm from pypy.jit.backend.ppc.ppcgen.helper.regalloc import (_check_imm_arg, prepare_cmp_op, @@ -20,6 +21,10 @@ import pypy.jit.backend.ppc.ppcgen.register as r from pypy.jit.codewriter import heaptracker +# xxx hack: set a default value for TargetToken._arm_loop_code. If 0, we know +# that it is a LABEL that was not compiled yet. +TargetToken._ppc_loop_code = 0 + class TempInt(TempBox): type = INT @@ -525,17 +530,30 @@ def prepare_jump(self, op): descr = op.getdescr() - assert isinstance(descr, LoopToken) - nonfloatlocs = descr._ppc_arglocs[0] + assert isinstance(descr, TargetToken) + self.jump_target_descr = descr + arglocs = self.assembler.target_arglocs(descr) - tmploc = r.r0 - src_locs1 = [self.loc(op.getarg(i)) for i in range(op.numargs()) - if op.getarg(i).type != FLOAT] - assert tmploc not in nonfloatlocs - dst_locs1 = [loc for loc in nonfloatlocs if loc is not None] - remap_frame_layout_mixed(self.assembler, - src_locs1, dst_locs1, tmploc, - [], [], None) + # get temporary locs + tmploc = r.SCRATCH + + # Part about non-floats + src_locations1 = [] + dst_locations1 = [] + + # Build the four lists + for i in range(op.numargs()): + box = op.getarg(i) + src_loc = self.loc(box) + dst_loc = arglocs[i] + if box.type != FLOAT: + src_locations1.append(src_loc) + dst_locations1.append(dst_loc) + else: + assert 0, "not implemented yet" + + remap_frame_layout(self.assembler, src_locations1, + dst_locations1, tmploc) return [] def prepare_setfield_gc(self, op): @@ -870,6 +888,46 @@ self.possibly_free_var(op.result) return [res_loc] + def prepare_label(self, op): + # XXX big refactoring needed? + descr = op.getdescr() + assert isinstance(descr, TargetToken) + inputargs = op.getarglist() + arglocs = [None] * len(inputargs) + # + # we use force_spill() on the boxes that are not going to be really + # used any more in the loop, but that are kept alive anyway + # by being in a next LABEL's or a JUMP's argument or fail_args + # of some guard + position = self.rm.position + for arg in inputargs: + assert isinstance(arg, Box) + if self.last_real_usage.get(arg, -1) <= position: + self.force_spill_var(arg) + + # + for i in range(len(inputargs)): + arg = inputargs[i] + assert isinstance(arg, Box) + loc = self.loc(arg) + arglocs[i] = loc + if loc.is_reg(): + self.frame_manager.mark_as_free(arg) + # + descr._ppc_arglocs = arglocs + descr._ppc_loop_code = self.assembler.mc.currpos() + descr._ppc_clt = self.assembler.current_clt + self.assembler.target_tokens_currently_compiling[descr] = None + self.possibly_free_vars_for_op(op) + # + # if the LABEL's descr is precisely the target of the JUMP at the + # end of the same loop, i.e. if what we are compiling is a single + # loop that ends up jumping to this LABEL, then we can now provide + # the hints about the expected position of the spilled variables. + jump_op = self.final_jump_op + if jump_op is not None and jump_op.getdescr() is descr: + self._compute_hint_frame_locations_from_descr(descr) + def prepare_guard_call_may_force(self, op, guard_op): faildescr = guard_op.getdescr() fail_index = self.cpu.get_fail_descr_number(faildescr) _______________________________________________ pypy-commit mailing list pypy-commit@python.org http://mail.python.org/mailman/listinfo/pypy-commit