Author: Armin Rigo <ar...@tunes.org> Branch: ppc-updated-backend Changeset: r79095:4865720d70df Date: 2015-08-21 01:03 -0700 http://bitbucket.org/pypy/pypy/changeset/4865720d70df/
Log: One test passes! diff --git a/rpython/jit/backend/llsupport/llmodel.py b/rpython/jit/backend/llsupport/llmodel.py --- a/rpython/jit/backend/llsupport/llmodel.py +++ b/rpython/jit/backend/llsupport/llmodel.py @@ -282,6 +282,7 @@ ll_threadlocal_addr = rffi.cast(llmemory.Address, self._debug_errno_container) llop.gc_writebarrier(lltype.Void, ll_frame) + import pdb;pdb.set_trace() ll_frame = func(ll_frame, ll_threadlocal_addr) finally: if not self.translate_support_code: diff --git a/rpython/jit/backend/ppc/opassembler.py b/rpython/jit/backend/ppc/opassembler.py --- a/rpython/jit/backend/ppc/opassembler.py +++ b/rpython/jit/backend/ppc/opassembler.py @@ -346,10 +346,46 @@ _mixin_ = True + def emit_increment_debug_counter(self, op, arglocs, regalloc): + [addr_loc, value_loc] = arglocs + self.mc.load(value_loc.value, addr_loc.value, 0) + self.mc.addi(value_loc.value, value_loc.value, 1) + self.mc.store(value_loc.value, addr_loc.value, 0) + def emit_finish(self, op, arglocs, regalloc): - [argloc] = arglocs - self._gen_epilogue(self.mc) - # ARM has a fcond argument to this function, returned at the end + base_ofs = self.cpu.get_baseofs_of_frame_field() + if len(arglocs) == 2: + [return_val, fail_descr_loc] = arglocs + self.mc.std(return_val.value, r.SPP.value, base_ofs) + else: + [fail_descr_loc] = arglocs + + ofs = self.cpu.get_ofs_of_frame_field('jf_descr') + self.mc.load_imm(r.r5, fail_descr_loc.getint()) + self.mc.std(r.r5.value, r.SPP.value, ofs) + + ## arglist = op.getarglist() + ## if arglist and arglist[0].type == REF: + ## if self._finish_gcmap: + ## # we're returning with a guard_not_forced_2, and + ## # additionally we need to say that eax/rax contains + ## # a reference too: + ## self._finish_gcmap[0] |= r_uint(1) + ## gcmap = self._finish_gcmap + ## else: + ## gcmap = self.gcmap_for_finish + ## self.push_gcmap(self.mc, gcmap, store=True) + ## elif self._finish_gcmap: + ## # we're returning with a guard_not_forced_2 + ## gcmap = self._finish_gcmap + ## self.push_gcmap(self.mc, gcmap, store=True) + ## else: + ## # note that the 0 here is redundant, but I would rather + ## # keep that one and kill all the others + ## ofs = self.cpu.get_ofs_of_frame_field('jf_gcmap') + ## self.mc.MOV_bi(ofs, 0) + # exit function + self._call_footer() def emit_jump(self, op, arglocs, regalloc): # The backend's logic assumes that the target code is in a piece of diff --git a/rpython/jit/backend/ppc/ppc_assembler.py b/rpython/jit/backend/ppc/ppc_assembler.py --- a/rpython/jit/backend/ppc/ppc_assembler.py +++ b/rpython/jit/backend/ppc/ppc_assembler.py @@ -85,23 +85,11 @@ # OFFSET_STACK_ARGS += MAX_REG_PARAMS * WORD def __init__(self, cpu, translate_support_code=False): - self.cpu = cpu - self.mc = None - self.memcpy_addr = 0 - self.pending_guards = None - self.fail_boxes_count = 0 - self.current_clt = None - self.malloc_slowpath = 0 - self.wb_slowpath = [0, 0, 0, 0] - self._regalloc = None - self.datablockwrapper = None - self.max_stack_params = 0 - self.propagate_exception_path = 0 + BaseAssembler.__init__(self, cpu, translate_support_code) + self.loop_run_counters = [] + self.setup_failure_recovery() self.stack_check_slowpath = 0 - self.setup_failure_recovery() - self._debug = False - self.loop_run_counters = [] - self.debug_counter_descr = cpu.fielddescrof(DEBUG_COUNTER, 'i') + self.teardown() def set_debug(self, v): self._debug = v @@ -645,11 +633,12 @@ return mc.materialize(self.cpu, [], self.cpu.gc_ll_descr.gcrootmap) def _gen_epilogue(self, mc): + XXX gcrootmap = self.cpu.gc_ll_descr.gcrootmap if gcrootmap and gcrootmap.is_shadow_stack: self.gen_footer_shadowstack(gcrootmap, mc) - # save SPP in r5 - # (assume that r5 has been written to failboxes) + + # save SPP back in r3 mc.mr(r.r5.value, r.SPP.value) self._restore_nonvolatiles(mc, r.r5) # load old backchain into r4 @@ -682,6 +671,12 @@ # self.mc.b_offset(loophead) def _call_header(self): + if IS_PPC_64: + # Reserve space for a function descriptor, 3 words + self.mc.write64(0) + self.mc.write64(0) + self.mc.write64(0) + # Build a new stackframe of size STD_FRAME_SIZE_IN_BYTES self.mc.store_update(r.SP.value, r.SP.value, -STD_FRAME_SIZE_IN_BYTES) self.mc.mflr(r.SCRATCH.value) @@ -758,6 +753,27 @@ pmc.bc(4, 1, offset) # jump if SCRATCH <= r16, i. e. not(SCRATCH > r16) pmc.overwrite() + def _call_footer(self): + # the return value is the jitframe + self.mc.mr(r.r3.value, r.SPP.value) + + gcrootmap = self.cpu.gc_ll_descr.gcrootmap + if gcrootmap and gcrootmap.is_shadow_stack: + self._call_footer_shadowstack(gcrootmap) + + # load old backchain into r4 + self.mc.load(r.r4.value, r.SP.value, + STD_FRAME_SIZE_IN_BYTES + LR_BC_OFFSET) + + # restore registers r25 to r31 + for i, reg in enumerate(REGISTERS_SAVED): + self.mc.load(reg.value, r.SP.value, + GPR_SAVE_AREA_OFFSET + i * WORD) + + self.mc.addi(r.SP.value, r.SP.value, STD_FRAME_SIZE_IN_BYTES) + self.mc.mtlr(r.r4.value) # restore LR + self.mc.blr() + def setup(self, looptoken): BaseAssembler.setup(self, looptoken) assert self.memcpy_addr != 0, "setup_once() not called?" @@ -776,38 +792,6 @@ self.frame_depth_to_patch = [] #self.max_stack_params = 0 - def _append_debugging_code(self, operations, tp, number, token): - counter = self._register_counter(tp, number, token) - c_adr = ConstInt(rffi.cast(lltype.Signed, counter)) - box = BoxInt() - box2 = BoxInt() - ops = [ResOperation(rop.GETFIELD_RAW, [c_adr], - box, descr=self.debug_counter_descr), - ResOperation(rop.INT_ADD, [box, ConstInt(1)], box2), - ResOperation(rop.SETFIELD_RAW, [c_adr, box2], - None, descr=self.debug_counter_descr)] - operations.extend(ops) - - @specialize.argtype(1) - def _inject_debugging_code(self, looptoken, operations, tp, number): - if self._debug: - # before doing anything, let's increase a counter - s = 0 - for op in operations: - s += op.getopnum() - looptoken._ppc_debug_checksum = s - - newoperations = [] - self._append_debugging_code(newoperations, tp, number, - None) - for op in operations: - newoperations.append(op) - if op.getopnum() == rop.LABEL: - self._append_debugging_code(newoperations, 'l', number, - op.getdescr()) - operations = newoperations - return operations - def update_frame_depth(self, frame_depth): baseofs = self.cpu.get_baseofs_of_frame_field() self.current_clt.frame_info.update_frame_depth(baseofs, frame_depth) @@ -852,6 +836,9 @@ full_size = self.mc.get_relative_pos() # rawstart = self.materialize_loop(looptoken) + if IS_PPC_64: # fix the function descriptor (3 words) + rffi.cast(rffi.LONGP, rawstart)[0] = rawstart + 3 * WORD + # self.patch_stack_checks(frame_depth_no_fixed_size + JITFRAME_FIXED_SIZE, rawstart) looptoken._ll_loop_code = looppos + rawstart @@ -1027,22 +1014,9 @@ return size def teardown(self): - self.patch_list = None - self.pending_guards = None + self.pending_guard_tokens = None + self.mc = None self.current_clt = None - self.mc = None - self._regalloc = None - assert self.datablockwrapper is None - self.max_stack_params = 0 - - def gen_64_bit_func_descr(self): - return self.datablockwrapper.malloc_aligned(3*WORD, alignment=1) - - def write_64_bit_func_descr(self, descr, start_addr): - data = rffi.cast(rffi.CArrayPtr(lltype.Signed), descr) - data[0] = start_addr - data[1] = 0 - data[2] = 0 def compute_frame_depth(self, spilling_area, param_depth): PARAMETER_AREA = param_depth * WORD @@ -1433,8 +1407,5 @@ func = getattr(AssemblerPPC, methname).im_func operations_with_guard[value] = func -AssemblerPPC.operations = operations -AssemblerPPC.operations_with_guard = operations_with_guard - class BridgeAlreadyCompiled(Exception): pass diff --git a/rpython/jit/backend/ppc/regalloc.py b/rpython/jit/backend/ppc/regalloc.py --- a/rpython/jit/backend/ppc/regalloc.py +++ b/rpython/jit/backend/ppc/regalloc.py @@ -30,6 +30,7 @@ from rpython.jit.backend.llsupport.descr import unpack_interiorfielddescr from rpython.rlib.objectmodel import we_are_translated from rpython.jit.codewriter.effectinfo import EffectInfo +from rpython.rlib import rgc # 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. @@ -302,6 +303,9 @@ selected_reg=selected_reg) def walk_operations(self, inputargs, operations): + from rpython.jit.backend.ppc.ppc_assembler import ( + operations_with_guard as asm_operations_with_guard, + operations as asm_operations) i = 0 #self.operations = operations while i < len(operations): @@ -314,13 +318,22 @@ self.possibly_free_vars_for_op(op) continue if self.can_merge_with_next_guard(op, i, operations): - oplist_with_guard[op.getopnum()](self, op, operations[i + 1]) + arglocs = oplist_with_guard[op.getopnum()](self, op, + operations[i + 1]) + assert arglocs is not None + asm_operations_with_guard[op.getopnum()](self.assembler, op, + operations[i + 1], + arglocs, self) i += 1 elif not we_are_translated() and op.getopnum() == -124: self._consider_force_spill(op) else: - oplist[op.getopnum()](self, op) + arglocs = oplist[op.getopnum()](self, op) + if arglocs is not None: + asm_operations[op.getopnum()](self.assembler, op, + arglocs, self) self.possibly_free_vars_for_op(op) + self.free_temp_vars() self.rm._check_invariants() self.fprm._check_invariants() i += 1 @@ -530,15 +543,17 @@ return [loc1, res] def prepare_finish(self, op): - if op.numargs() > 0: - loc = self.loc(op.getarg(0)) - self.possibly_free_var(op.getarg(0)) + descr = op.getdescr() + fail_descr = cast_instance_to_gcref(descr) + # we know it does not move, but well + rgc._make_sure_does_not_move(fail_descr) + fail_descr = rffi.cast(lltype.Signed, fail_descr) + if op.numargs() == 1: + loc = self.make_sure_var_in_reg(op.getarg(0)) + locs = [loc, imm(fail_descr)] else: - descr = op.getdescr() - fail_descr = cast_instance_to_gcref(descr) - fail_descr = rffi.cast(lltype.Signed, fail_descr) - loc = imm(fail_descr) - return [loc] + locs = [imm(fail_descr)] + return locs def prepare_call_malloc_gc(self, op): return self._prepare_call(op) @@ -748,6 +763,12 @@ prepare_getfield_raw_pure = prepare_getfield_gc prepare_getfield_gc_pure = prepare_getfield_gc + def prepare_increment_debug_counter(self, op): + args = op.getarglist() + base_loc = self._ensure_value_is_boxed(args[0]) + temp_loc = self.get_scratch_reg(INT, args) + return [base_loc, temp_loc] + def prepare_getinteriorfield_gc(self, op): t = unpack_interiorfielddescr(op.getdescr()) ofs, itemsize, fieldsize, sign = t _______________________________________________ pypy-commit mailing list pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit