[pypy-commit] pypy arm-backend-2: implement changes needed for target/label functionality
bivab
noreply at buildbot.pypy.org
Thu Dec 29 09:57:39 CET 2011
Author: David Schneider <david.schneider at picle.org>
Branch: arm-backend-2
Changeset: r50948:3a1fca872e84
Date: 2011-12-29 09:49 +0100
http://bitbucket.org/pypy/pypy/changeset/3a1fca872e84/
Log: implement changes needed for target/label functionality
diff --git a/pypy/jit/backend/arm/assembler.py b/pypy/jit/backend/arm/assembler.py
--- a/pypy/jit/backend/arm/assembler.py
+++ b/pypy/jit/backend/arm/assembler.py
@@ -10,7 +10,7 @@
PC_OFFSET, N_REGISTERS_SAVED_BY_MALLOC
from pypy.jit.backend.arm.codebuilder import ARMv7Builder, OverwritingBuilder
from pypy.jit.backend.arm.regalloc import (Regalloc, ARMFrameManager,
- ARMv7RegisterMananger, check_imm_arg,
+ ARMv7RegisterManager, check_imm_arg,
operations as regalloc_operations,
operations_with_guard as regalloc_operations_with_guard)
from pypy.jit.backend.arm.jump import remap_frame_layout
@@ -87,11 +87,11 @@
assert self.memcpy_addr != 0, 'setup_once() not called?'
self.mc = ARMv7Builder()
self.pending_guards = []
- self.currently_compiling_loop = None
assert self.datablockwrapper is None
allblocks = self.get_asmmemmgr_blocks(looptoken)
self.datablockwrapper = MachineDataBlockWrapper(self.cpu.asmmemmgr,
allblocks)
+ self.target_tokens_currently_compiling = {}
return operations
def teardown(self):
@@ -99,7 +99,6 @@
self._regalloc = None
self.mc = None
self.pending_guards = None
- self.currently_compiling_loop = None
assert self.datablockwrapper is None
def setup_once(self):
@@ -326,10 +325,10 @@
mc.SUB_rr(r.r0.value, r.r1.value, r.r0.value)
addr = self.cpu.gc_ll_descr.get_malloc_slowpath_addr()
# XXX replace with an STMxx operation
- for reg, ofs in ARMv7RegisterMananger.REGLOC_TO_COPY_AREA_OFS.items():
+ for reg, ofs in ARMv7RegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
mc.STR_ri(reg.value, r.fp.value, imm=ofs)
mc.BL(addr)
- for reg, ofs in ARMv7RegisterMananger.REGLOC_TO_COPY_AREA_OFS.items():
+ for reg, ofs in ARMv7RegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
mc.LDR_ri(reg.value, r.fp.value, imm=ofs)
mc.CMP_ri(r.r0.value, 0)
@@ -546,9 +545,9 @@
self.mc.VLDR(r.vfp_ip.value, r.ip.value)
self.mov_loc_loc(r.vfp_ip, loc)
- def gen_direct_bootstrap_code(self, loop_head, looptoken, inputargs):
+ def gen_direct_bootstrap_code(self, loop_head, arglocs, frame_depth, inputargs):
self.gen_func_prolog()
- nonfloatlocs, floatlocs = looptoken._arm_arglocs
+ nonfloatlocs, floatlocs = arglocs
reg_args = count_reg_args(inputargs)
@@ -627,7 +626,7 @@
sp_patch_location = self._prepare_sp_patch_position()
self.mc.B_offs(loop_head)
- self._patch_sp_offset(sp_patch_location, looptoken._arm_frame_depth)
+ self._patch_sp_offset(sp_patch_location, frame_depth)
def _dump(self, ops, type='loop'):
debug_start('jit-backend-ops')
@@ -642,8 +641,11 @@
clt.allgcrefs = []
looptoken.compiled_loop_token = clt
+ if not we_are_translated():
+ # Arguments should be unique
+ assert len(set(inputargs)) == len(inputargs)
+
operations = self.setup(looptoken, operations)
- self.currently_compiling_loop = looptoken
self._dump(operations)
self.align()
@@ -659,25 +661,31 @@
looptoken._arm_loop_code = loop_head
looptoken._arm_bootstrap_code = 0
- looptoken._arm_frame_depth = -1
+ clt.frame_depth = -1
frame_depth = self._assemble(operations, regalloc)
- looptoken._arm_frame_depth = frame_depth
- self._patch_sp_offset(sp_patch_location, looptoken._arm_frame_depth)
+ clt.frame_depth = frame_depth
+ self._patch_sp_offset(sp_patch_location, frame_depth)
self.align()
direct_bootstrap_code = self.mc.currpos()
- self.gen_direct_bootstrap_code(loop_head, looptoken, inputargs)
+ self.gen_direct_bootstrap_code(loop_head, arglocs,
+ frame_depth, inputargs)
self.write_pending_failure_recoveries()
- loop_start = self.materialize_loop(looptoken)
- looptoken._arm_bootstrap_code = loop_start
- direct_code_start = loop_start + direct_bootstrap_code
+
+ rawstart = self.materialize_loop(looptoken)
+ direct_code_start = rawstart + direct_bootstrap_code
+
+ looptoken._arm_bootstrap_code = rawstart
looptoken._arm_direct_bootstrap_code = direct_code_start
- self.process_pending_guards(loop_start)
+
+ self.process_pending_guards(rawstart)
+ self.fixup_target_tokens(rawstart)
+
if log and not we_are_translated():
print 'Loop', inputargs, operations
- self.mc._dump_trace(loop_start,
+ self.mc._dump_trace(rawstart,
'loop_%s.asm' % self.cpu.total_compiled_loops)
print 'Done assembling loop with token %r' % looptoken
self.teardown()
@@ -688,7 +696,7 @@
frame_depth = regalloc.frame_manager.get_frame_depth()
jump_target_descr = regalloc.jump_target_descr
if jump_target_descr is not None:
- frame_depth = max(frame_depth, jump_target_descr._arm_frame_depth)
+ frame_depth = max(frame_depth, jump_target_descr._arm_clt.frame_depth)
return frame_depth
def assemble_bridge(self, faildescr, inputargs, operations,
@@ -698,7 +706,7 @@
assert isinstance(faildescr, AbstractFailDescr)
code = faildescr._failure_recovery_code
enc = rffi.cast(rffi.CCHARP, code)
- frame_depth = faildescr._arm_frame_depth
+ frame_depth = faildescr._arm_current_frame_depth
arglocs = self.decode_inputargs(enc)
if not we_are_translated():
assert len(inputargs) == len(arglocs)
@@ -713,17 +721,27 @@
self._patch_sp_offset(sp_patch_location, frame_depth)
self.write_pending_failure_recoveries()
- bridge_start = self.materialize_loop(original_loop_token)
- self.process_pending_guards(bridge_start)
+ rawstart = self.materialize_loop(original_loop_token)
+ self.process_pending_guards(rawstart)
self.patch_trace(faildescr, original_loop_token,
- bridge_start, regalloc)
- if log and not we_are_translated():
- print 'Bridge', inputargs, operations
- self.mc._dump_trace(bridge_start, 'bridge_%d.asm' %
- self.cpu.total_compiled_bridges)
+ rawstart, regalloc)
+ self.fixup_target_tokens(rawstart)
+
+ if not we_are_translated():
+ # for the benefit of tests
+ faildescr._arm_bridge_frame_depth = frame_depth
+ if log:
+ print 'Bridge', inputargs, operations
+ self.mc._dump_trace(rawstart, 'bridge_%d.asm' %
+ self.cpu.total_compiled_bridges)
+ self.current_clt.frame_depth = max(self.current_clt.frame_depth, frame_depth)
self.teardown()
+ def fixup_target_tokens(self, rawstart):
+ for targettoken in self.target_tokens_currently_compiling:
+ targettoken._arm_loop_code += rawstart
+ self.target_tokens_currently_compiling = None
def target_arglocs(self, loop_token):
return loop_token._arm_arglocs
@@ -745,7 +763,7 @@
memaddr = self._gen_path_to_exit_path(descr, tok.failargs,
tok.faillocs, save_exc=tok.save_exc)
# store info on the descr
- descr._arm_frame_depth = tok.faillocs[0].getint()
+ descr._arm_current_frame_depth = tok.faillocs[0].getint()
descr._failure_recovery_code = memaddr
descr._arm_guard_pos = pos
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
@@ -22,7 +22,8 @@
from pypy.jit.backend.arm.locations import imm
from pypy.jit.backend.llsupport import symbolic
from pypy.jit.metainterp.history import (Box, AbstractFailDescr,
- LoopToken, INT, FLOAT, REF)
+ INT, FLOAT, REF)
+from pypy.jit.metainterp.history import JitCellToken, TargetToken
from pypy.jit.metainterp.resoperation import rop
from pypy.rlib.objectmodel import we_are_translated
from pypy.rpython.lltypesystem import lltype, rffi, rstr
@@ -305,15 +306,14 @@
def emit_op_jump(self, op, arglocs, regalloc, fcond):
descr = op.getdescr()
- assert isinstance(descr, LoopToken)
+ assert isinstance(descr, TargetToken)
assert fcond == c.AL
self._insert_checks()
- if descr is self.currently_compiling_loop:
+ if descr in self.target_tokens_currently_compiling:
self.mc.B_offs(descr._arm_loop_code, fcond)
else:
- target = descr._arm_bootstrap_code + descr._arm_loop_code
- self.mc.B(target, fcond)
+ self.mc.B(descr._arm_loop_code, fcond)
return fcond
def emit_op_finish(self, op, arglocs, regalloc, fcond):
@@ -373,8 +373,7 @@
regalloc, fcond, op.result)
descr = op.getdescr()
#XXX Hack, Hack, Hack
- if (op.result and not we_are_translated()
- and not isinstance(descr, LoopToken)):
+ if (op.result and not we_are_translated()):
#XXX check result type
loc = regalloc.rm.call_result_location(op.result)
size = descr.get_result_size(False)
@@ -999,7 +998,7 @@
self._write_fail_index(fail_index)
descr = op.getdescr()
- assert isinstance(descr, LoopToken)
+ assert isinstance(descr, JitCellToken)
# XXX check this
assert op.numargs() == len(descr._arm_arglocs[0])
resbox = TempInt()
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
@@ -16,7 +16,8 @@
from pypy.jit.codewriter import longlong
from pypy.jit.metainterp.history import (Const, ConstInt, ConstFloat, ConstPtr,
Box, BoxPtr,
- INT, REF, FLOAT, LoopToken)
+ INT, REF, FLOAT)
+from pypy.jit.metainterp.history import JitCellToken, TargetToken
from pypy.jit.metainterp.resoperation import rop
from pypy.jit.backend.llsupport.descr import BaseFieldDescr, BaseArrayDescr, \
BaseSizeDescr, InteriorFieldDescr
@@ -26,6 +27,11 @@
from pypy.jit.codewriter.effectinfo import EffectInfo
+# 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._arm_loop_code = 0
+
+
class TempInt(TempBox):
type = INT
@@ -80,6 +86,7 @@
else:
return loc.position
+
def void(self, op, fcond):
return []
@@ -128,7 +135,7 @@
return reg
-class ARMv7RegisterMananger(RegisterManager):
+class ARMv7RegisterManager(RegisterManager):
all_regs = r.all_regs
box_types = None # or a list of acceptable types
no_lower_byte_regs = all_regs
@@ -192,6 +199,7 @@
self.assembler = assembler
self.frame_manager = frame_manager
self.jump_target_descr = None
+ self.final_jump_op = None
def loc(self, var):
if var.type == FLOAT:
@@ -294,7 +302,7 @@
fm = self.frame_manager
asm = self.assembler
self.vfprm = VFPRegisterManager(longevity, fm, asm)
- self.rm = ARMv7RegisterMananger(longevity, fm, asm)
+ self.rm = ARMv7RegisterManager(longevity, fm, asm)
return useful
def prepare_loop(self, inputargs, operations):
@@ -629,11 +637,24 @@
op = operations[-1]
if op.getopnum() != rop.JUMP:
return
+ self.final_jump_op = op
descr = op.getdescr()
- assert isinstance(descr, LoopToken)
+ assert isinstance(descr, TargetToken)
+ if descr._arm_loop_code != 0:
+ # if the target LABEL was already compiled, i.e. if it belongs
+ # to some already-compiled piece of code
+ self._compute_hint_frame_locations_from_descr(descr)
+ #else:
+ # The loop ends in a JUMP going back to a LABEL in the same loop.
+ # We cannot fill 'hint_frame_locations' immediately, but we can
+ # wait until the corresponding prepare_op_label() to know where the
+ # we would like the boxes to be after the jump.
+
+ def _compute_hint_frame_locations_from_descr(self, descr):
nonfloatlocs, floatlocs = self.assembler.target_arglocs(descr)
- for i in range(op.numargs()):
- box = op.getarg(i)
+ jump_op = self.final_jump_op
+ for i in range(jump_op.numargs()):
+ box = jump_op.getarg(i)
if isinstance(box, Box):
loc = nonfloatlocs[i]
if loc is not None and loc.is_stack():
@@ -647,16 +668,13 @@
def prepare_op_jump(self, op, fcond):
descr = op.getdescr()
- assert isinstance(descr, LoopToken)
+ assert isinstance(descr, TargetToken)
self.jump_target_descr = descr
nonfloatlocs, floatlocs = self.assembler.target_arglocs(descr)
# get temporary locs
tmploc = r.ip
- box = TempFloat()
- # compute 'vfptmploc' to be all_regs[0] by spilling what is there
- vfptmp = self.vfprm.all_regs[0]
- vfptmploc = self.vfprm.force_allocate_reg(box, selected_reg=vfptmp)
+ vfptmploc = r.vfp_ip
# Part about non-floats
# XXX we don't need a copy, we only just the original list
@@ -671,7 +689,6 @@
remap_frame_layout_mixed(self.assembler,
src_locations1, dst_locations1, tmploc,
src_locations2, dst_locations2, vfptmploc)
- self.possibly_free_var(box)
return []
def prepare_op_setfield_gc(self, op, fcond):
@@ -1066,6 +1083,39 @@
self.possibly_free_var(op.result)
return [res_loc]
+ def prepare_op_label(self, op, fcond):
+ # XXX big refactoring needed?
+ descr = op.getdescr()
+ assert isinstance(descr, TargetToken)
+ inputargs = op.getarglist()
+ floatlocs = [None] * len(inputargs)
+ nonfloatlocs = [None] * len(inputargs)
+
+ for i in range(len(inputargs)):
+ arg = inputargs[i]
+ assert not isinstance(arg, Const)
+ loc = self.loc(arg)
+ if arg.type == FLOAT:
+ floatlocs[i] = loc
+ else:
+ nonfloatlocs[i] = loc
+ if loc.is_reg():
+ self.frame_manager.mark_as_free(arg)
+ descr._arm_arglocs = nonfloatlocs, floatlocs
+ descr._arm_loop_code = self.assembler.mc.currpos()
+ descr._arm_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)
+ return None
+
def prepare_guard_call_may_force(self, op, guard_op, fcond):
faildescr = guard_op.getdescr()
fail_index = self.cpu.get_fail_descr_number(faildescr)
@@ -1106,7 +1156,7 @@
def prepare_guard_call_assembler(self, op, guard_op, fcond):
descr = op.getdescr()
- assert isinstance(descr, LoopToken)
+ assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
assert jd is not None
size = jd.portal_calldescr.get_result_size(
diff --git a/pypy/jit/backend/arm/runner.py b/pypy/jit/backend/arm/runner.py
--- a/pypy/jit/backend/arm/runner.py
+++ b/pypy/jit/backend/arm/runner.py
@@ -115,7 +115,7 @@
faildescr = self.get_fail_descr_from_number(fail_index)
rffi.cast(TP, addr_of_force_index)[0] = ~fail_index
# start of "no gc operation!" block
- frame_depth = faildescr._arm_frame_depth * WORD
+ frame_depth = faildescr._arm_current_frame_depth * WORD
addr_end_of_frame = (addr_of_force_index -
(frame_depth +
len(all_regs) * WORD +
diff --git a/pypy/jit/backend/arm/test/test_assembler.py b/pypy/jit/backend/arm/test/test_assembler.py
--- a/pypy/jit/backend/arm/test/test_assembler.py
+++ b/pypy/jit/backend/arm/test/test_assembler.py
@@ -1,8 +1,6 @@
-from pypy.jit.backend.arm import arch
from pypy.jit.backend.arm import conditions as c
from pypy.jit.backend.arm import registers as r
-from pypy.jit.backend.arm.arch import WORD
-from pypy.jit.backend.arm.arch import arm_int_div, arm_int_div_sign
+from pypy.jit.backend.arm.arch import arm_int_div
from pypy.jit.backend.arm.assembler import AssemblerARM
from pypy.jit.backend.arm.locations import imm
from pypy.jit.backend.arm.test.support import skip_unless_arm, run_asm
@@ -10,21 +8,21 @@
from pypy.jit.metainterp.resoperation import rop
from pypy.rpython.annlowlevel import llhelper
-from pypy.rpython.lltypesystem import lltype, rffi, llmemory
-from pypy.jit.metainterp.history import LoopToken
+from pypy.rpython.lltypesystem import lltype, rffi
+from pypy.jit.metainterp.history import JitCellToken
from pypy.jit.backend.model import CompiledLoopToken
skip_unless_arm()
CPU = getcpuclass()
+
+
class TestRunningAssembler(object):
def setup_method(self, method):
cpu = CPU(None, None)
- #lp = LoopToken()
- #lp.compiled_loop_token = CompiledLoopToken(cpu, None)
self.a = AssemblerARM(cpu)
self.a.setup_once()
- token = LoopToken()
+ token = JitCellToken()
clt = CompiledLoopToken(cpu, 0)
clt.allgcrefs = []
token.compiled_loop_token = clt
@@ -33,7 +31,8 @@
def test_make_operation_list(self):
i = rop.INT_ADD
from pypy.jit.backend.arm import assembler
- assert assembler.asm_operations[i] is AssemblerARM.emit_op_int_add.im_func
+ assert assembler.asm_operations[i] \
+ is AssemblerARM.emit_op_int_add.im_func
def test_load_small_int_to_reg(self):
self.a.gen_func_prolog()
@@ -77,7 +76,6 @@
self.a.gen_func_epilog()
assert run_asm(self.a) == 464
-
def test_or(self):
self.a.gen_func_prolog()
self.a.mc.MOV_ri(r.r1.value, 8)
@@ -115,7 +113,7 @@
self.a.gen_func_prolog()
self.a.mc.MOV_ri(r.r1.value, 1)
loop_head = self.a.mc.currpos()
- self.a.mc.CMP_ri(r.r1.value, 0) # z=0, z=1
+ self.a.mc.CMP_ri(r.r1.value, 0) # z=0, z=1
self.a.mc.MOV_ri(r.r1.value, 0, cond=c.NE)
self.a.mc.MOV_ri(r.r1.value, 7, cond=c.EQ)
self.a.mc.B_offs(loop_head, c.NE)
@@ -143,7 +141,8 @@
self.a.mc.MOV_ri(r.r0.value, 123, cond=c.NE)
for x in range(15):
- self.a.mc.POP([reg.value for reg in r.callee_restored_registers], cond=c.NE)
+ self.a.mc.POP(
+ [reg.value for reg in r.callee_restored_registers], cond=c.NE)
self.a.mc.MOV_ri(r.r1.value, 33)
self.a.mc.MOV_ri(r.r0.value, 23)
@@ -160,7 +159,8 @@
self.a.mc.MOV_ri(r.r0.value, 123, cond=c.NE)
for x in range(100):
- self.a.mc.POP([reg.value for reg in r.callee_restored_registers], cond=c.NE)
+ self.a.mc.POP(
+ [reg.value for reg in r.callee_restored_registers], cond=c.NE)
self.a.mc.MOV_ri(r.r1.value, 33)
self.a.mc.MOV_ri(r.r0.value, 23)
@@ -216,7 +216,6 @@
self.a.gen_func_epilog()
assert run_asm(self.a) == -36
-
def test_bl_with_conditional_exec(self):
functype = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
call_addr = rffi.cast(lltype.Signed, llhelper(functype, callme))
@@ -240,7 +239,7 @@
assert run_asm(self.a) == 2478
def test_load_store(self):
- x = 0x60002224
+ x = 0x60002224
self.a.gen_func_prolog()
self.a.mc.gen_load_int(r.r1.value, x)
self.a.mc.MOV_ri(r.r3.value, 8)
@@ -249,7 +248,7 @@
self.a.gen_func_epilog()
assert run_asm(self.a) == x
+
def callme(inp):
i = inp + 10
return i
-
diff --git a/pypy/jit/backend/arm/test/test_calling_convention.py b/pypy/jit/backend/arm/test/test_calling_convention.py
--- a/pypy/jit/backend/arm/test/test_calling_convention.py
+++ b/pypy/jit/backend/arm/test/test_calling_convention.py
@@ -1,13 +1,15 @@
from pypy.rpython.annlowlevel import llhelper
-from pypy.jit.metainterp.history import LoopToken
+from pypy.jit.metainterp.history import JitCellToken
from pypy.jit.backend.test.calling_convention_test import TestCallingConv, parse
from pypy.rpython.lltypesystem import lltype
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.backend.arm.test.support import skip_unless_arm
skip_unless_arm()
-# ../../test/calling_convention_test.py
+
class TestARMCallingConvention(TestCallingConv):
+ # ../../test/calling_convention_test.py
+
def test_call_argument_spilling(self):
# bug when we have a value in r0, that is overwritten by an argument
# and needed after the call, so that the register gets spilled after it
@@ -28,7 +30,7 @@
i99 = call(ConstClass(func_ptr), 22, descr=calldescr)
finish(%s, i99)""" % (args, args)
loop = parse(ops, namespace=locals())
- looptoken = LoopToken()
+ looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
for x in range(11):
self.cpu.set_future_value_int(x, x)
diff --git a/pypy/jit/backend/arm/test/test_gc_integration.py b/pypy/jit/backend/arm/test/test_gc_integration.py
--- a/pypy/jit/backend/arm/test/test_gc_integration.py
+++ b/pypy/jit/backend/arm/test/test_gc_integration.py
@@ -3,63 +3,74 @@
"""
import py
-from pypy.jit.metainterp.history import BoxInt, ConstInt,\
- BoxPtr, ConstPtr, TreeLoop
+from pypy.jit.metainterp.history import BoxInt, \
+ BoxPtr, TreeLoop, TargetToken
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.codewriter import heaptracker
from pypy.jit.backend.llsupport.descr import GcCache
from pypy.jit.backend.llsupport.gc import GcLLDescription
from pypy.jit.backend.detect_cpu import getcpuclass
-from pypy.jit.backend.arm.regalloc import Regalloc
from pypy.jit.backend.arm.arch import WORD
-from pypy.jit.tool.oparser import parse
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
from pypy.rpython.annlowlevel import llhelper
-from pypy.rpython.lltypesystem import rclass, rstr
-from pypy.jit.backend.llsupport.gc import GcLLDescr_framework, GcPtrFieldDescr
+from pypy.rpython.lltypesystem import rclass
+from pypy.jit.backend.llsupport.gc import GcLLDescr_framework
from pypy.jit.backend.arm.test.test_regalloc import MockAssembler
from pypy.jit.backend.arm.test.test_regalloc import BaseTestRegalloc
-from pypy.jit.backend.arm.regalloc import ARMv7RegisterMananger, ARMFrameManager,\
- VFPRegisterManager
+from pypy.jit.backend.arm.regalloc import ARMFrameManager, VFPRegisterManager
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.backend.arm.test.support import skip_unless_arm
+from pypy.jit.backend.arm.regalloc import Regalloc, ARMv7RegisterManager
skip_unless_arm()
CPU = getcpuclass()
+
class MockGcRootMap(object):
is_shadow_stack = False
+
def get_basic_shape(self, is_64_bit):
return ['shape']
+
def add_frame_offset(self, shape, offset):
shape.append(offset)
+
def add_callee_save_reg(self, shape, reg_index):
- index_to_name = { 1: 'ebx', 2: 'esi', 3: 'edi' }
+ index_to_name = {1: 'ebx', 2: 'esi', 3: 'edi'}
shape.append(index_to_name[reg_index])
+
def compress_callshape(self, shape, datablockwrapper):
assert datablockwrapper == 'fakedatablockwrapper'
assert shape[0] == 'shape'
return ['compressed'] + shape[1:]
+
class MockGcRootMap2(object):
is_shadow_stack = False
+
def get_basic_shape(self, is_64_bit):
return ['shape']
+
def add_frame_offset(self, shape, offset):
shape.append(offset)
+
def add_callee_save_reg(self, shape, reg_index):
- index_to_name = { 1: 'ebx', 2: 'esi', 3: 'edi' }
+ index_to_name = {1: 'ebx', 2: 'esi', 3: 'edi'}
shape.append(index_to_name[reg_index])
+
def compress_callshape(self, shape, datablockwrapper):
assert datablockwrapper == 'fakedatablockwrapper'
assert shape[0] == 'shape'
return ['compressed'] + shape[1:]
+
class MockGcDescr(GcCache):
is_shadow_stack = False
+
def get_funcptr_for_new(self):
return 123
+
get_funcptr_for_newarray = get_funcptr_for_new
get_funcptr_for_newstr = get_funcptr_for_new
get_funcptr_for_newunicode = get_funcptr_for_new
@@ -74,13 +85,14 @@
record_constptrs = GcLLDescr_framework.record_constptrs.im_func
rewrite_assembler = GcLLDescr_framework.rewrite_assembler.im_func
+
class TestRegallocDirectGcIntegration(object):
def test_mark_gc_roots(self):
py.test.skip('roots')
cpu = CPU(None, None)
cpu.setup_once()
- regalloc = RegAlloc(MockAssembler(cpu, MockGcDescr(False)))
+ regalloc = Regalloc(MockAssembler(cpu, MockGcDescr(False)))
regalloc.assembler.datablockwrapper = 'fakedatablockwrapper'
boxes = [BoxPtr() for i in range(len(ARMv7RegisterManager.all_regs))]
longevity = {}
@@ -95,7 +107,8 @@
for box in boxes:
regalloc.rm.try_allocate_reg(box)
TP = lltype.FuncType([], lltype.Signed)
- calldescr = cpu.calldescrof(TP, TP.ARGS, TP.RESULT, EffectInfo.MOST_GENERAL)
+ calldescr = cpu.calldescrof(TP, TP.ARGS, TP.RESULT,
+ EffectInfo.MOST_GENERAL)
regalloc.rm._check_invariants()
box = boxes[0]
regalloc.position = 0
@@ -129,6 +142,7 @@
descr0 = cpu.fielddescrof(S, 'int')
ptr0 = struct_ref
+ targettoken = TargetToken()
namespace = locals().copy()
@@ -153,6 +167,7 @@
def test_bug_0(self):
ops = '''
[i0, i1, i2, i3, i4, i5, i6, i7, i8]
+ label(i0, i1, i2, i3, i4, i5, i6, i7, i8, descr=targettoken)
guard_value(i2, 1) [i2, i3, i4, i5, i6, i7, i0, i1, i8]
guard_class(i4, 138998336) [i4, i5, i6, i7, i0, i1, i8]
i11 = getfield_gc(i4, descr=descr0)
@@ -180,7 +195,7 @@
guard_false(i32) [i4, i6, i7, i0, i1, i24]
i33 = getfield_gc(i0, descr=descr0)
guard_value(i33, ConstPtr(ptr0)) [i4, i6, i7, i0, i1, i33, i24]
- jump(i0, i1, 1, 17, i4, ConstPtr(ptr0), i6, i7, i24)
+ jump(i0, i1, 1, 17, i4, ConstPtr(ptr0), i6, i7, i24, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0, 0, 0, 0, 0, 0], run=False)
@@ -322,17 +337,22 @@
class Seen(Exception):
pass
+
class GCDescrFastpathMallocVarsize(GCDescrFastpathMalloc):
def can_inline_malloc_varsize(self, arraydescr, num_elem):
return num_elem < 5
+
def get_funcptr_for_newarray(self):
return 52
+
def init_array_descr(self, A, descr):
descr.tid = self._counter
self._counter += 1
+
def args_for_new_array(self, descr):
raise Seen("args_for_new_array")
+
class TestMallocVarsizeFastpath(BaseTestRegalloc):
def setup_method(self, method):
cpu = CPU(None, None)
diff --git a/pypy/jit/backend/arm/test/test_generated.py b/pypy/jit/backend/arm/test/test_generated.py
--- a/pypy/jit/backend/arm/test/test_generated.py
+++ b/pypy/jit/backend/arm/test/test_generated.py
@@ -3,10 +3,10 @@
AbstractDescr,
BasicFailDescr,
BoxInt, Box, BoxPtr,
- LoopToken,
ConstInt, ConstPtr,
BoxObj, Const,
ConstObj, BoxFloat, ConstFloat)
+from pypy.jit.metainterp.history import JitCellToken
from pypy.jit.metainterp.resoperation import ResOperation, rop
from pypy.rpython.test.test_llinterp import interpret
from pypy.jit.backend.detect_cpu import getcpuclass
@@ -40,7 +40,7 @@
ResOperation(rop.GUARD_TRUE, [v12], None, descr=faildescr1),
ResOperation(rop.FINISH, [v9, v6, v10, v2, v8, v5, v1, v4], None, descr=faildescr2),
]
- looptoken = LoopToken()
+ looptoken = JitCellToken()
operations[2].setfailargs([v12, v8, v3, v2, v1, v11])
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -12)
@@ -101,7 +101,7 @@
]
operations[2].setfailargs([v10, v6])
operations[9].setfailargs([v15, v7, v10, v18, v4, v17, v1])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 16)
cpu.set_future_value_int(1, 5)
@@ -152,7 +152,7 @@
]
operations[2].setfailargs([v8, v3])
operations[4].setfailargs([v2, v12, v1, v3, v4])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -5)
cpu.set_future_value_int(1, 24)
@@ -203,7 +203,7 @@
ResOperation(rop.FINISH, [v8, v2, v6, v5, v7, v1, v10], None, descr=faildescr2),
]
operations[5].setfailargs([])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 19)
cpu.set_future_value_int(1, -3)
@@ -254,7 +254,7 @@
ResOperation(rop.GUARD_NO_OVERFLOW, [], None, descr=faildescr1),
ResOperation(rop.FINISH, [v1, v4, v10, v8, v7, v3], None, descr=faildescr2),
]
- looptoken = LoopToken()
+ looptoken = JitCellToken()
operations[5].setfailargs([])
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 1073741824)
@@ -316,7 +316,7 @@
ResOperation(rop.GUARD_FALSE, [tmp17], None, descr=faildescr3),
ResOperation(rop.FINISH, [v8, v10, v6, v3, v2, v9], None, descr=faildescr4),
]
- looptoken = LoopToken()
+ looptoken = JitCellToken()
operations[1].setfailargs([v8, v6, v1])
operations[7].setfailargs([v4])
operations[9].setfailargs([v10, v13])
@@ -376,7 +376,7 @@
]
operations[1].setfailargs([v6, v8, v1, v4])
operations[8].setfailargs([v5, v9])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -8)
cpu.set_future_value_int(1, 0)
@@ -434,7 +434,7 @@
operations[3].setfailargs([])
operations[-4].setfailargs([v15])
operations[-2].setfailargs([v9, v4, v10, v11, v14])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -39)
cpu.set_future_value_int(1, -18)
@@ -497,7 +497,7 @@
operations[1].setfailargs([v9, v1])
operations[5].setfailargs([v10, v2, v11, v3])
operations[9].setfailargs([v5, v7, v12, v14, v2, v13, v8])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 0)
cpu.set_future_value_int(1, -2)
@@ -547,7 +547,7 @@
ResOperation(rop.FINISH, [v8, v2, v10, v6, v7, v9, v5, v4], None, descr=faildescr2),
]
operations[2].setfailargs([v10, v3, v6, v11, v9, v2])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 3)
cpu.set_future_value_int(1, -5)
@@ -604,7 +604,7 @@
]
operations[-2].setfailargs([v4, v10, v3, v9, v14, v2])
operations[4].setfailargs([v14])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 14)
cpu.set_future_value_int(1, -20)
diff --git a/pypy/jit/backend/arm/test/test_recompilation.py b/pypy/jit/backend/arm/test/test_recompilation.py
--- a/pypy/jit/backend/arm/test/test_recompilation.py
+++ b/pypy/jit/backend/arm/test/test_recompilation.py
@@ -2,14 +2,16 @@
from pypy.jit.backend.arm.test.support import skip_unless_arm
skip_unless_arm()
+
class TestRecompilation(BaseTestRegalloc):
def test_compile_bridge_not_deeper(self):
ops = '''
[i0]
+ label(i0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_lt(i1, 20)
guard_true(i2, descr=fdescr1) [i1]
- jump(i1)
+ jump(i1, descr=targettoken)
'''
loop = self.interpret(ops, [0])
assert self.getint(0) == 20
@@ -23,16 +25,19 @@
fail = self.run(loop)
assert fail.identifier == 2
assert self.getint(0) == 21
-
+
def test_compile_bridge_deeper(self):
ops = '''
[i0]
+ label(i0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_lt(i1, 20)
guard_true(i2, descr=fdescr1) [i1]
- jump(i1)
+ jump(i1, descr=targettoken)
'''
loop = self.interpret(ops, [0])
+ previous = loop._jitcelltoken.compiled_loop_token.frame_depth
+ #assert loop._jitcelltoken.compiled_loop_token.param_depth == 0
assert self.getint(0) == 20
ops = '''
[i1]
@@ -41,12 +46,17 @@
i5 = int_add(i4, 1)
i6 = int_add(i5, 1)
i7 = int_add(i5, i4)
+ force_spill(i5)
i8 = int_add(i7, 1)
i9 = int_add(i8, 1)
finish(i3, i4, i5, i6, i7, i8, i9, descr=fdescr2)
'''
bridge = self.attach_bridge(ops, loop, -2)
- descr = loop.operations[2].getdescr()
+ descr = loop.operations[3].getdescr()
+ new = descr._arm_bridge_frame_depth
+ #assert descr._x86_bridge_param_depth == 0
+ # the force_spill() forces the stack to grow
+ assert new > previous
self.cpu.set_future_value_int(0, 0)
fail = self.run(loop)
assert fail.identifier == 2
@@ -58,21 +68,23 @@
def test_bridge_jump_to_other_loop(self):
loop = self.interpret('''
[i0, i10, i11, i12, i13, i14, i15, i16]
+ label(i0, i10, i11, i12, i13, i14, i15, i16, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_lt(i1, 20)
guard_true(i2, descr=fdescr1) [i1]
- jump(i1, i10, i11, i12, i13, i14, i15, i16)
+ jump(i1, i10, i11, i12, i13, i14, i15, i16, descr=targettoken)
''', [0])
other_loop = self.interpret('''
[i3]
+ label(i3, descr=targettoken2)
guard_false(i3, descr=fdescr2) [i3]
- jump(i3)
+ jump(i3, descr=targettoken2)
''', [1])
ops = '''
[i3]
- jump(i3, 1, 2, 3, 4, 5, 6, 7, descr=looptoken)
+ jump(i3, 1, 2, 3, 4, 5, 6, 7, descr=targettoken)
'''
- bridge = self.attach_bridge(ops, other_loop, 0, looptoken=loop.token)
+ bridge = self.attach_bridge(ops, other_loop, 1)
self.cpu.set_future_value_int(0, 1)
fail = self.run(other_loop)
assert fail.identifier == 1
@@ -80,6 +92,7 @@
def test_bridge_jumps_to_self_deeper(self):
loop = self.interpret('''
[i0, i1, i2, i31, i32, i33]
+ label(i0, i1, i2, i31, i32, i33, descr=targettoken)
i98 = same_as(0)
i99 = same_as(1)
i30 = int_add(i1, i2)
@@ -88,7 +101,7 @@
guard_false(i4) [i98, i3]
i5 = int_lt(i3, 20)
guard_true(i5) [i99, i3]
- jump(i3, i30, 1, i30, i30, i30)
+ jump(i3, i30, 1, i30, i30, i30, descr=targettoken)
''', [0])
assert self.getint(0) == 0
assert self.getint(1) == 1
@@ -98,16 +111,19 @@
i8 = int_add(i3, 1)
i6 = int_add(i8, i10)
i7 = int_add(i3, i6)
+ force_spill(i6)
+ force_spill(i7)
+ force_spill(i8)
i12 = int_add(i7, i8)
i11 = int_add(i12, i6)
- jump(i3, i12, i11, i10, i6, i7, descr=looptoken)
+ jump(i3, i12, i11, i10, i6, i7, descr=targettoken)
'''
- bridge = self.attach_bridge(ops, loop, 5, looptoken=loop.token)
- guard_op = loop.operations[5]
- #loop_frame_depth = loop.token._x86_frame_depth
- #assert loop.token._x86_param_depth == 0
- ## XXX: Maybe add enough ops to force stack on 64-bit as well?
- # assert guard_op.getdescr()._arm_bridge_frame_depth > loop_frame_depth
+ loop_frame_depth = loop._jitcelltoken.compiled_loop_token.frame_depth
+ bridge = self.attach_bridge(ops, loop, 6)
+ guard_op = loop.operations[6]
+ #assert loop._jitcelltoken.compiled_loop_token.param_depth == 0
+ # the force_spill() forces the stack to grow
+ assert guard_op.getdescr()._arm_bridge_frame_depth > loop_frame_depth
#assert guard_op.getdescr()._x86_bridge_param_depth == 0
self.cpu.set_future_value_int(0, 0)
self.cpu.set_future_value_int(1, 0)
@@ -119,6 +135,7 @@
def test_bridge_jumps_to_self_shallower(self):
loop = self.interpret('''
[i0, i1, i2]
+ label(i0, i1, i2, descr=targettoken)
i98 = same_as(0)
i99 = same_as(1)
i3 = int_add(i0, 1)
@@ -126,19 +143,19 @@
guard_false(i4) [i98, i3]
i5 = int_lt(i3, 20)
guard_true(i5) [i99, i3]
- jump(i3, i1, i2)
+ jump(i3, i1, i2, descr=targettoken)
''', [0])
assert self.getint(0) == 0
assert self.getint(1) == 1
ops = '''
[i97, i3]
- jump(i3, 0, 1, descr=looptoken)
+ jump(i3, 0, 1, descr=targettoken)
'''
- bridge = self.attach_bridge(ops, loop, 4, looptoken=loop.token)
+ bridge = self.attach_bridge(ops, loop, 5)
self.cpu.set_future_value_int(0, 0)
self.cpu.set_future_value_int(1, 0)
self.cpu.set_future_value_int(2, 0)
self.run(loop)
assert self.getint(0) == 1
assert self.getint(1) == 20
-
+
diff --git a/pypy/jit/backend/arm/test/test_regalloc.py b/pypy/jit/backend/arm/test/test_regalloc.py
--- a/pypy/jit/backend/arm/test/test_regalloc.py
+++ b/pypy/jit/backend/arm/test/test_regalloc.py
@@ -3,19 +3,29 @@
"""
import py
-from pypy.jit.metainterp.history import BasicFailDescr
+from pypy.jit.metainterp.history import BasicFailDescr, \
+ JitCellToken, \
+ TargetToken
+from pypy.jit.metainterp.resoperation import rop
from pypy.jit.backend.llsupport.descr import GcCache
from pypy.jit.backend.detect_cpu import getcpuclass
from pypy.jit.backend.arm.regalloc import Regalloc, ARMFrameManager
+from pypy.jit.backend.llsupport.regalloc import is_comparison_or_ovf_op
from pypy.jit.tool.oparser import parse
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.annlowlevel import llhelper
from pypy.rpython.lltypesystem import rclass, rstr
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.backend.arm.test.support import skip_unless_arm
+from pypy.jit.codewriter import longlong
skip_unless_arm()
+def test_is_comparison_or_ovf_op():
+ assert not is_comparison_or_ovf_op(rop.INT_ADD)
+ assert is_comparison_or_ovf_op(rop.INT_ADD_OVF)
+ assert is_comparison_or_ovf_op(rop.INT_EQ)
+
CPU = getcpuclass()
@@ -85,38 +95,49 @@
FPTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
f_fptr = llhelper(FPTR, f)
- f_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT, EffectInfo.MOST_GENERAL)
+ f_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT,
+ EffectInfo.MOST_GENERAL)
zero_division_tp, zero_division_value = cpu.get_zero_division_error()
zd_addr = cpu.cast_int_to_adr(zero_division_tp)
zero_division_error = llmemory.cast_adr_to_ptr(zd_addr,
lltype.Ptr(rclass.OBJECT_VTABLE))
- raising_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT, EffectInfo.MOST_GENERAL)
+ raising_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT,
+ EffectInfo.MOST_GENERAL)
+ targettoken = TargetToken()
+ targettoken2 = TargetToken()
fdescr1 = BasicFailDescr(1)
fdescr2 = BasicFailDescr(2)
fdescr3 = BasicFailDescr(3)
+ def setup_method(self, meth):
+ self.targettoken._arm_loop_code = 0
+ self.targettoken2._arm_loop_code = 0
+
def f1(x):
- return x+1
+ return x + 1
def f2(x, y):
- return x*y
+ return x * y
def f10(*args):
assert len(args) == 10
return sum(args)
F1PTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
- F2PTR = lltype.Ptr(lltype.FuncType([lltype.Signed]*2, lltype.Signed))
- F10PTR = lltype.Ptr(lltype.FuncType([lltype.Signed]*10, lltype.Signed))
+ F2PTR = lltype.Ptr(lltype.FuncType([lltype.Signed] * 2, lltype.Signed))
+ F10PTR = lltype.Ptr(lltype.FuncType([lltype.Signed] * 10, lltype.Signed))
f1ptr = llhelper(F1PTR, f1)
f2ptr = llhelper(F2PTR, f2)
f10ptr = llhelper(F10PTR, f10)
- f1_calldescr = cpu.calldescrof(F1PTR.TO, F1PTR.TO.ARGS, F1PTR.TO.RESULT, EffectInfo.MOST_GENERAL)
- f2_calldescr = cpu.calldescrof(F2PTR.TO, F2PTR.TO.ARGS, F2PTR.TO.RESULT, EffectInfo.MOST_GENERAL)
- f10_calldescr = cpu.calldescrof(F10PTR.TO, F10PTR.TO.ARGS, F10PTR.TO.RESULT, EffectInfo.MOST_GENERAL)
+ f1_calldescr = cpu.calldescrof(F1PTR.TO, F1PTR.TO.ARGS, F1PTR.TO.RESULT,
+ EffectInfo.MOST_GENERAL)
+ f2_calldescr = cpu.calldescrof(F2PTR.TO, F2PTR.TO.ARGS, F2PTR.TO.RESULT,
+ EffectInfo.MOST_GENERAL)
+ f10_calldescr = cpu.calldescrof(F10PTR.TO, F10PTR.TO.ARGS,
+ F10PTR.TO.RESULT, EffectInfo.MOST_GENERAL)
namespace = locals().copy()
type_system = 'lltype'
@@ -128,18 +149,21 @@
def interpret(self, ops, args, run=True):
loop = self.parse(ops)
- self.cpu.compile_loop(loop.inputargs, loop.operations, loop.token)
+ looptoken = JitCellToken()
+ self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
for i, arg in enumerate(args):
if isinstance(arg, int):
self.cpu.set_future_value_int(i, arg)
elif isinstance(arg, float):
+ arg = longlong.getfloatstorage(arg)
self.cpu.set_future_value_float(i, arg)
else:
assert isinstance(lltype.typeOf(arg), lltype.Ptr)
llgcref = lltype.cast_opaque_ptr(llmemory.GCREF, arg)
self.cpu.set_future_value_ref(i, llgcref)
+ loop._jitcelltoken = looptoken
if run:
- self.cpu.execute_token(loop.token)
+ self.cpu.execute_token(looptoken)
return loop
def prepare_loop(self, ops):
@@ -167,10 +191,7 @@
gcref = self.cpu.get_latest_value_ref(index)
return lltype.cast_opaque_ptr(T, gcref)
- def attach_bridge(self, ops, loop, guard_op_index, looptoken=None, **kwds):
- if looptoken is not None:
- self.namespace = self.namespace.copy()
- self.namespace['looptoken'] = looptoken
+ def attach_bridge(self, ops, loop, guard_op_index, **kwds):
guard_op = loop.operations[guard_op_index]
assert guard_op.is_guard()
bridge = self.parse(ops, **kwds)
@@ -178,20 +199,22 @@
[box.type for box in guard_op.getfailargs()])
faildescr = guard_op.getdescr()
self.cpu.compile_bridge(faildescr, bridge.inputargs, bridge.operations,
- loop.token)
+ loop._jitcelltoken)
return bridge
def run(self, loop):
- return self.cpu.execute_token(loop.token)
+ return self.cpu.execute_token(loop._jitcelltoken)
+
class TestRegallocSimple(BaseTestRegalloc):
def test_simple_loop(self):
ops = '''
[i0]
+ label(i0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_lt(i1, 20)
guard_true(i2) [i1]
- jump(i1)
+ jump(i1, descr=targettoken)
'''
self.interpret(ops, [0])
assert self.getint(0) == 20
@@ -199,27 +222,29 @@
def test_two_loops_and_a_bridge(self):
ops = '''
[i0, i1, i2, i3]
+ label(i0, i1, i2, i3, descr=targettoken)
i4 = int_add(i0, 1)
i5 = int_lt(i4, 20)
guard_true(i5) [i4, i1, i2, i3]
- jump(i4, i1, i2, i3)
+ jump(i4, i1, i2, i3, descr=targettoken)
'''
- loop = self.interpret(ops, [0, 0, 0, 0])
+ self.interpret(ops, [0, 0, 0, 0])
ops2 = '''
[i5]
+ label(i5, descr=targettoken2)
i1 = int_add(i5, 1)
i3 = int_add(i1, 1)
i4 = int_add(i3, 1)
i2 = int_lt(i4, 30)
guard_true(i2) [i4]
- jump(i4)
+ jump(i4, descr=targettoken2)
'''
loop2 = self.interpret(ops2, [0])
bridge_ops = '''
[i4]
- jump(i4, i4, i4, i4, descr=looptoken)
+ jump(i4, i4, i4, i4, descr=targettoken)
'''
- bridge = self.attach_bridge(bridge_ops, loop2, 4, looptoken=loop.token)
+ self.attach_bridge(bridge_ops, loop2, 5)
self.cpu.set_future_value_int(0, 0)
self.run(loop2)
assert self.getint(0) == 31
@@ -230,10 +255,11 @@
def test_pointer_arg(self):
ops = '''
[i0, p0]
+ label(i0, p0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_lt(i1, 10)
guard_true(i2) [p0]
- jump(i1, p0)
+ jump(i1, p0, descr=targettoken)
'''
S = lltype.GcStruct('S')
ptr = lltype.malloc(S)
@@ -257,7 +283,7 @@
'''
loop = self.interpret(ops, [0])
assert self.getint(0) == 1
- bridge = self.attach_bridge(bridge_ops, loop, 2)
+ self.attach_bridge(bridge_ops, loop, 2)
self.cpu.set_future_value_int(0, 0)
self.run(loop)
assert self.getint(0) == 1
@@ -284,7 +310,7 @@
loop = self.interpret(ops, [0, 10])
assert self.getint(0) == 0
assert self.getint(1) == 10
- bridge = self.attach_bridge(bridge_ops, loop, 0)
+ self.attach_bridge(bridge_ops, loop, 0)
self.cpu.set_future_value_int(0, 0)
self.cpu.set_future_value_int(1, 10)
self.run(loop)
@@ -311,10 +337,11 @@
def test_spill_for_constant(self):
ops = '''
[i0, i1, i2, i3]
+ label(i0, i1, i2, i3, descr=targettoken)
i4 = int_add(3, i1)
i5 = int_lt(i4, 30)
guard_true(i5) [i0, i4, i2, i3]
- jump(1, i4, 3, 4)
+ jump(1, i4, 3, 4, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0])
assert self.getints(4) == [1, 30, 3, 4]
@@ -322,43 +349,47 @@
def test_spill_for_constant_lshift(self):
ops = '''
[i0, i2, i1, i3]
+ label(i0, i2, i1, i3, descr=targettoken)
i4 = int_lshift(1, i1)
i5 = int_add(1, i1)
i6 = int_lt(i5, 30)
guard_true(i6) [i4, i5, i2, i3]
- jump(i4, 3, i5, 4)
+ jump(i4, 3, i5, 4, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0])
- assert self.getints(4) == [1<<29, 30, 3, 4]
+ assert self.getints(4) == [1 << 29, 30, 3, 4]
ops = '''
[i0, i1, i2, i3]
+ label(i0, i1, i2, i3, descr=targettoken)
i4 = int_lshift(1, i1)
i5 = int_add(1, i1)
i6 = int_lt(i5, 30)
guard_true(i6) [i4, i5, i2, i3]
- jump(i4, i5, 3, 4)
+ jump(i4, i5, 3, 4, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0])
- assert self.getints(4) == [1<<29, 30, 3, 4]
+ assert self.getints(4) == [1 << 29, 30, 3, 4]
ops = '''
[i0, i3, i1, i2]
+ label(i0, i3, i1, i2, descr=targettoken)
i4 = int_lshift(1, i1)
i5 = int_add(1, i1)
i6 = int_lt(i5, 30)
guard_true(i6) [i4, i5, i2, i3]
- jump(i4, 4, i5, 3)
+ jump(i4, 4, i5, 3, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0])
- assert self.getints(4) == [1<<29, 30, 3, 4]
+ assert self.getints(4) == [1 << 29, 30, 3, 4]
def test_result_selected_reg_via_neg(self):
ops = '''
[i0, i1, i2, i3]
+ label(i0, i1, i2, i3, descr=targettoken)
i6 = int_neg(i2)
i7 = int_add(1, i1)
i4 = int_lt(i7, 10)
guard_true(i4) [i0, i6, i7]
- jump(1, i7, i2, i6)
+ jump(1, i7, i2, i6, descr=targettoken)
'''
self.interpret(ops, [0, 0, 3, 0])
assert self.getints(3) == [1, -3, 10]
@@ -366,11 +397,12 @@
def test_compare_memory_result_survives(self):
ops = '''
[i0, i1, i2, i3]
+ label(i0, i1, i2, i3, descr=targettoken)
i4 = int_lt(i0, i1)
i5 = int_add(i3, 1)
i6 = int_lt(i5, 30)
guard_true(i6) [i4]
- jump(i0, i1, i4, i5)
+ jump(i0, i1, i4, i5, descr=targettoken)
'''
self.interpret(ops, [0, 10, 0, 0])
assert self.getint(0) == 1
@@ -378,10 +410,11 @@
def test_jump_different_args(self):
ops = '''
[i0, i15, i16, i18, i1, i2, i3]
+ label(i0, i15, i16, i18, i1, i2, i3, descr=targettoken)
i4 = int_add(i3, 1)
i5 = int_lt(i4, 20)
guard_true(i5) [i2, i1]
- jump(i0, i18, i15, i16, i2, i1, i4)
+ jump(i0, i18, i15, i16, i2, i1, i4, descr=targettoken)
'''
self.interpret(ops, [0, 1, 2, 3])
@@ -450,6 +483,7 @@
regalloc = self.prepare_loop(ops)
assert len(regalloc.rm.reg_bindings) == 2
+
class TestRegallocCompOps(BaseTestRegalloc):
def test_cmp_op_0(self):
@@ -463,9 +497,11 @@
self.interpret(ops, [0, 1])
assert self.getint(0) == 0
+
class TestRegallocMoreRegisters(BaseTestRegalloc):
cpu = BaseTestRegalloc.cpu
+ targettoken = TargetToken()
S = lltype.GcStruct('S', ('field', lltype.Char))
fielddescr = cpu.fielddescrof(S, 'field')
@@ -513,7 +549,7 @@
strsetitem(p0, 1, i)
finish()
'''
- llstr = rstr.mallocstr(10)
+ llstr = rstr.mallocstr(10)
self.interpret(ops, [llstr, ord('a')])
assert llstr.chars[1] == 'a'
@@ -570,6 +606,7 @@
def test_division_optimized(self):
ops = '''
[i7, i6]
+ label(i7, i6, descr=targettoken)
i18 = int_floordiv(i7, i6)
i19 = int_xor(i7, i6)
i21 = int_lt(i19, 0)
@@ -577,12 +614,13 @@
i23 = int_is_true(i22)
i24 = int_eq(i6, 4)
guard_false(i24) [i18]
- jump(i18, i6)
+ jump(i18, i6, descr=targettoken)
'''
self.interpret(ops, [10, 4])
assert self.getint(0) == 2
# FIXME: Verify that i19 - i23 are removed
+
class TestRegallocFloats(BaseTestRegalloc):
def test_float_add(self):
py.test.skip('need floats')
@@ -603,7 +641,8 @@
finish(f9, f10, f2, f3, f4, f5, f6, f7, f8)
'''
self.interpret(ops, [0.1, .2, .3, .4, .5, .6, .7, .8, .9])
- assert self.getfloats(9) == [.1+.2, .9+3.5, .3, .4, .5, .6, .7, .8, .9]
+ assert self.getfloats(9) == [.1 + .2, .9 + 3.5, .3,
+ .4, .5, .6, .7, .8, .9]
def test_lt_const(self):
py.test.skip('need floats')
@@ -633,9 +672,10 @@
i9 = float_ne(f9, 0.0)
finish(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
'''
- loop = self.interpret(ops, [0.0, .1, .2, .3, .4, .5, .6, .7, .8, .9])
+ self.interpret(ops, [0.0, .1, .2, .3, .4, .5, .6, .7, .8, .9])
assert self.getints(9) == [0, 1, 1, 1, 1, 1, 1, 1, 1]
+
class TestRegAllocCallAndStackDepth(BaseTestRegalloc):
def expected_param_depth(self, num_args):
# Assumes the arguments are all non-float
@@ -647,7 +687,7 @@
i10 = call(ConstClass(f1ptr), i0, descr=f1_calldescr)
finish(i10, i1, i2, i3, i4, i5, i6, i7, i8, i9)
'''
- loop = self.interpret(ops, [4, 7, 9, 9 ,9, 9, 9, 9, 9, 9, 9])
+ self.interpret(ops, [4, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9])
assert self.getints(11) == [5, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9]
def test_two_calls(self):
@@ -657,8 +697,8 @@
i11 = call(ConstClass(f2ptr), i10, i1, descr=f2_calldescr)
finish(i11, i1, i2, i3, i4, i5, i6, i7, i8, i9)
'''
- loop = self.interpret(ops, [4, 7, 9, 9 ,9, 9, 9, 9, 9, 9, 9])
- assert self.getints(11) == [5*7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9]
+ self.interpret(ops, [4, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9])
+ assert self.getints(11) == [5 * 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9]
def test_call_many_arguments(self):
ops = '''
@@ -666,7 +706,7 @@
i8 = call(ConstClass(f10ptr), 1, i0, i1, i2, i3, i4, i5, i6, i7, 10, descr=f10_calldescr)
finish(i8)
'''
- loop = self.interpret(ops, [2, 3, 4, 5, 6, 7, 8, 9])
+ self.interpret(ops, [2, 3, 4, 5, 6, 7, 8, 9])
assert self.getint(0) == 55
def test_bridge_calls_1(self):
@@ -683,13 +723,12 @@
i3 = call(ConstClass(f2ptr), i2, i1, descr=f2_calldescr)
finish(i3, descr=fdescr2)
'''
- bridge = self.attach_bridge(ops, loop, -2)
-
+ self.attach_bridge(ops, loop, -2)
self.cpu.set_future_value_int(0, 4)
self.cpu.set_future_value_int(1, 7)
self.run(loop)
- assert self.getint(0) == 5*7
+ assert self.getint(0) == 5 * 7
def test_bridge_calls_2(self):
ops = '''
@@ -699,27 +738,28 @@
finish(i1)
'''
loop = self.interpret(ops, [4, 7])
- assert self.getint(0) == 4*7
+ assert self.getint(0) == 4 * 7
ops = '''
[i2]
i3 = call(ConstClass(f1ptr), i2, descr=f1_calldescr)
finish(i3, descr=fdescr2)
'''
- bridge = self.attach_bridge(ops, loop, -2)
-
+ self.attach_bridge(ops, loop, -2)
self.cpu.set_future_value_int(0, 4)
self.cpu.set_future_value_int(1, 7)
self.run(loop)
assert self.getint(0) == 29
+
class TestJumps(BaseTestRegalloc):
def test_jump_with_consts(self):
loop = """
[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]
- jump(i1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, descr=targettoken)
+ jump(i1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, descr=targettoken)
"""
- large = self.interpret(loop, range(15), run=False)
+ self.interpret(loop, range(15), run=False)
# ensure compiling this loop works
assert 1
@@ -729,6 +769,7 @@
FUNCPTR = lltype.Ptr(lltype.FuncType([lltype.Signed, llmemory.GCREF],
lltype.Signed))
+
class FakeJitDriverSD:
index_of_virtualizable = -1
_assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
@@ -736,15 +777,16 @@
_assembler_helper_ptr)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
- lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), [lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
+ lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), \
+ [lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
loop1 = """
[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
i11 = int_add(i0, i1)
finish(i11, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10)
"""
large = self.interpret(loop1, range(11), run=False)
- large.token.outermost_jitdriver_sd = FakeJitDriverSD()
- self.namespace['looptoken'] = large.token
+ large._jitcelltoken.outermost_jitdriver_sd = FakeJitDriverSD()
+ self.namespace['looptoken'] = large._jitcelltoken
assert self.namespace['looptoken']._arm_bootstrap_code != 0
loop2 = """
[i0]
@@ -761,6 +803,7 @@
def test_far_far_jump(self):
ops = """
[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
+ label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, descr=targettoken)
i11 = int_add(i0, 1)
i12 = int_lt(i11, 2)
i13 = call(ConstClass(f_fptr), i12, descr=f_calldescr)
@@ -781,10 +824,11 @@
i29 = call(ConstClass(f_fptr), i12, descr=f_calldescr)
i30 = call(ConstClass(f_fptr), i12, descr=f_calldescr)
guard_true(i12) [i11, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
- jump(i11, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10)
+ jump(i11, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, descr=targettoken)
"""
self.interpret(ops, range(11))
- assert self.getint(0) == 2 # and not segfault()
+ assert self.getint(0) == 2 # and not segfault()
+
class TestStrOps(BaseTestRegalloc):
def test_newstr(self):
@@ -824,4 +868,3 @@
self.interpret(ops, [])
string = self.getptr(0, lltype.Ptr(rstr.STR))
assert len(string.chars) == 300
-
diff --git a/pypy/jit/backend/arm/test/test_regalloc2.py b/pypy/jit/backend/arm/test/test_regalloc2.py
--- a/pypy/jit/backend/arm/test/test_regalloc2.py
+++ b/pypy/jit/backend/arm/test/test_regalloc2.py
@@ -1,6 +1,7 @@
import py
from pypy.jit.metainterp.history import ResOperation, BoxInt, ConstInt,\
- BoxPtr, ConstPtr, BasicFailDescr, LoopToken
+ BoxPtr, ConstPtr, BasicFailDescr
+from pypy.jit.metainterp.history import JitCellToken
from pypy.jit.metainterp.resoperation import rop
from pypy.jit.backend.detect_cpu import getcpuclass
from pypy.jit.backend.arm.arch import WORD
@@ -22,7 +23,7 @@
]
cpu = CPU(None, None)
cpu.setup_once()
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 9)
cpu.execute_token(looptoken)
@@ -45,7 +46,7 @@
]
cpu = CPU(None, None)
cpu.setup_once()
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -10)
cpu.execute_token(looptoken)
@@ -142,7 +143,7 @@
]
cpu = CPU(None, None)
cpu.setup_once()
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, -13)
cpu.set_future_value_int(1, 10)
@@ -257,7 +258,7 @@
]
cpu = CPU(None, None)
cpu.setup_once()
- looptoken = LoopToken()
+ looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
cpu.set_future_value_int(0, 17)
cpu.set_future_value_int(1, -20)
diff --git a/pypy/jit/backend/arm/test/test_runner.py b/pypy/jit/backend/arm/test/test_runner.py
--- a/pypy/jit/backend/arm/test/test_runner.py
+++ b/pypy/jit/backend/arm/test/test_runner.py
@@ -4,25 +4,23 @@
boxfloat, \
constfloat
from pypy.jit.backend.arm.test.support import skip_unless_arm
-from pypy.jit.metainterp.history import (AbstractFailDescr,
- AbstractDescr,
- BasicFailDescr,
- BoxInt, Box, BoxPtr,
- LoopToken,
- ConstInt, ConstPtr,
- BoxObj, Const,
- ConstObj, BoxFloat, ConstFloat)
+from pypy.jit.metainterp.history import (BasicFailDescr,
+ BoxInt,
+ ConstInt)
from pypy.jit.metainterp.resoperation import ResOperation, rop
from pypy.jit.tool.oparser import parse
from pypy.rpython.lltypesystem import lltype, llmemory, rclass
from pypy.rpython.annlowlevel import llhelper
from pypy.jit.codewriter.effectinfo import EffectInfo
+from pypy.jit.metainterp.history import JitCellToken, TargetToken
skip_unless_arm()
+
class FakeStats(object):
pass
+
class TestARM(LLtypeBackendTest):
def setup_class(cls):
@@ -38,39 +36,41 @@
cpu = self.cpu
inp = [BoxInt(i) for i in range(1, 15)]
out = [BoxInt(i) for i in range(1, 15)]
- looptoken = LoopToken()
+ looptoken = JitCellToken()
+ targettoken = TargetToken()
operations = [
- ResOperation(rop.INT_ADD, [inp[0] , inp[1]], out[0]),
- ResOperation(rop.INT_ADD, [inp[2] , inp[3]], out[1]),
- ResOperation(rop.INT_ADD, [inp[4] , inp[5]], out[2]),
- ResOperation(rop.INT_ADD, [inp[6] , inp[7]], out[3]),
- ResOperation(rop.INT_ADD, [inp[8] , inp[9]], out[4]),
+ ResOperation(rop.LABEL, inp, None, descr=targettoken),
+ ResOperation(rop.INT_ADD, [inp[0], inp[1]], out[0]),
+ ResOperation(rop.INT_ADD, [inp[2], inp[3]], out[1]),
+ ResOperation(rop.INT_ADD, [inp[4], inp[5]], out[2]),
+ ResOperation(rop.INT_ADD, [inp[6], inp[7]], out[3]),
+ ResOperation(rop.INT_ADD, [inp[8], inp[9]], out[4]),
ResOperation(rop.INT_ADD, [inp[10], inp[11]], out[5]),
ResOperation(rop.INT_ADD, [inp[12], inp[13]], out[6]),
- ResOperation(rop.INT_ADD, [inp[0] , inp[1]], out[7]),
- ResOperation(rop.INT_ADD, [inp[2] , inp[3]], out[8]),
- ResOperation(rop.INT_ADD, [inp[4] , inp[5]], out[9]),
- ResOperation(rop.INT_ADD, [inp[6] , inp[7]], out[10]),
- ResOperation(rop.INT_ADD, [inp[8] , inp[9]], out[11]),
+ ResOperation(rop.INT_ADD, [inp[0], inp[1]], out[7]),
+ ResOperation(rop.INT_ADD, [inp[2], inp[3]], out[8]),
+ ResOperation(rop.INT_ADD, [inp[4], inp[5]], out[9]),
+ ResOperation(rop.INT_ADD, [inp[6], inp[7]], out[10]),
+ ResOperation(rop.INT_ADD, [inp[8], inp[9]], out[11]),
ResOperation(rop.INT_ADD, [inp[10], inp[11]], out[12]),
ResOperation(rop.INT_ADD, [inp[12], inp[13]], out[13]),
ResOperation(rop.FINISH, out, None, descr=BasicFailDescr(1)),
]
cpu.compile_loop(inp, operations, looptoken)
for i in range(1, 15):
- self.cpu.set_future_value_int(i-1, i)
- res = self.cpu.execute_token(looptoken)
- output = [self.cpu.get_latest_value_int(i-1) for i in range(1, 15)]
+ self.cpu.set_future_value_int(i - 1, i)
+ self.cpu.execute_token(looptoken)
+ output = [self.cpu.get_latest_value_int(i - 1) for i in range(1, 15)]
expected = [3, 7, 11, 15, 19, 23, 27, 3, 7, 11, 15, 19, 23, 27]
assert output == expected
def test_redirect_call_assember2(self):
- called = []
def assembler_helper(failindex, virtualizable):
return self.cpu.get_latest_value_int(0)
FUNCPTR = lltype.Ptr(lltype.FuncType([lltype.Signed, llmemory.GCREF],
lltype.Signed))
+
class FakeJitDriverSD:
index_of_virtualizable = -1
_assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
@@ -79,7 +79,7 @@
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)),
[lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
- lt1, lt2, lt3 = [LoopToken() for x in range(3)]
+ lt1, lt2, lt3 = [JitCellToken() for x in range(3)]
lt2.outermost_jitdriver_sd = FakeJitDriverSD()
loop1 = parse('''
[i0]
@@ -101,12 +101,12 @@
self.cpu.compile_loop(loop3.inputargs, loop3.operations, lt3)
self.cpu.compile_loop(loop1.inputargs, loop1.operations, lt1)
self.cpu.set_future_value_int(0, 11)
- res = self.cpu.execute_token(lt1)
+ self.cpu.execute_token(lt1)
assert self.cpu.get_latest_value_int(0) == 12
self.cpu.redirect_call_assembler(lt2, lt3)
self.cpu.set_future_value_int(0, 11)
- res = self.cpu.execute_token(lt1)
+ self.cpu.execute_token(lt1)
assert self.cpu.get_latest_value_int(0) == 10
def test_new_array_with_const_length(self):
@@ -172,6 +172,7 @@
TFloat = lltype.GcStruct('TFloat', ('parent', SFloat),
('next', lltype.Ptr(SFloat)))
+
def test_float_field(self):
if not self.cpu.supports_floats:
py.test.skip('requires floats')
diff --git a/pypy/jit/backend/arm/test/test_ztranslate_backend.py b/pypy/jit/backend/arm/test/test_ztranslate_backend.py
--- a/pypy/jit/backend/arm/test/test_ztranslate_backend.py
+++ b/pypy/jit/backend/arm/test/test_ztranslate_backend.py
@@ -4,10 +4,10 @@
AbstractDescr,
BasicFailDescr,
BoxInt, Box, BoxPtr,
- LoopToken,
ConstInt, ConstPtr,
BoxObj, Const,
ConstObj, BoxFloat, ConstFloat)
+from pypy.jit.metainterp.history import JitCellToken
from pypy.jit.metainterp.resoperation import ResOperation, rop
from pypy.rpython.test.test_llinterp import interpret
from pypy.jit.backend.detect_cpu import getcpuclass
@@ -27,7 +27,7 @@
i2 = BoxInt()
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
- looptoken = LoopToken()
+ looptoken = JitCellToken()
operations = [
ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1),
ResOperation(rop.INT_LE, [i1, ConstInt(9)], i2),
diff --git a/pypy/jit/backend/test/runner_test.py b/pypy/jit/backend/test/runner_test.py
--- a/pypy/jit/backend/test/runner_test.py
+++ b/pypy/jit/backend/test/runner_test.py
@@ -122,7 +122,7 @@
ResOperation(rop.FINISH, [i1], None, descr=BasicFailDescr(1))
]
inputargs = [i0]
- looptoken = LoopToken()
+ looptoken = JitCellToken()
self.cpu.compile_loop(inputargs, operations, looptoken)
self.cpu.set_future_value_float(0, longlong.getfloatstorage(2.8))
fail = self.cpu.execute_token(looptoken)
@@ -1248,7 +1248,7 @@
guard_false(i0) [f1, f2, f3]
finish()"""
loop = parse(loopops)
- looptoken = LoopToken()
+ looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
self.cpu.set_future_value_int(0, 1)
self.cpu.set_future_value_float(1, longlong.getfloatstorage(132.25))
@@ -1298,7 +1298,7 @@
ResOperation(rop.FINISH, [], None, descr=faildescr2),
]
operations[1].setfailargs([])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
self.cpu.compile_loop(inputargs, operations, looptoken)
#
cpu = self.cpu
@@ -1397,7 +1397,7 @@
ResOperation(rop.FINISH, [], None, descr=faildescr2),
]
operations[-2].setfailargs([])
- looptoken = LoopToken()
+ looptoken = JitCellToken()
self.cpu.compile_loop(inputargs, operations, looptoken)
#
cpu = self.cpu
@@ -2642,7 +2642,7 @@
del called[:]
self.cpu.done_with_this_frame_int_v = done_number
try:
- othertoken = LoopToken()
+ othertoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, othertoken)
for i in range(10):
self.cpu.set_future_value_int(i, i+1)
More information about the pypy-commit
mailing list