[pypy-commit] pypy arm-backend-2: in progress: implement the changes to the backend introduced by the jit-simplify-backendintf
bivab
noreply at buildbot.pypy.org
Fri Dec 30 17:13:05 CET 2011
Author: David Schneider <david.schneider at picle.org>
Branch: arm-backend-2
Changeset: r50962:206597c40644
Date: 2011-12-30 16:02 +0100
http://bitbucket.org/pypy/pypy/changeset/206597c40644/
Log: in progress: implement the changes to the backend introduced by the
jit-simplify-backendintf
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
@@ -57,6 +57,8 @@
END_OF_LOCS = '\xFF'
+ STACK_FIXED_AREA = -1
+
def __init__(self, cpu, failargs_limit=1000):
self.cpu = cpu
self.fail_boxes_int = values_array(lltype.Signed, failargs_limit)
@@ -67,10 +69,6 @@
self.fail_force_index = 0
self.setup_failure_recovery()
self.mc = None
- self.malloc_func_addr = 0
- self.malloc_array_func_addr = 0
- self.malloc_str_func_addr = 0
- self.malloc_unicode_func_addr = 0
self.memcpy_addr = 0
self.pending_guards = None
self._exit_code_addr = 0
@@ -79,6 +77,18 @@
self._regalloc = None
self.datablockwrapper = None
self.propagate_exception_path = 0
+ self._compute_stack_size()
+
+ def _compute_stack_size(self):
+ self.STACK_FIXED_AREA = len(r.callee_saved_registers) * WORD
+ self.STACK_FIXED_AREA += WORD # FORCE_TOKEN
+ self.STACK_FIXED_AREA += N_REGISTERS_SAVED_BY_MALLOC * WORD
+ if self.cpu.supports_floats:
+ self.STACK_FIXED_AREA += (len(r.callee_saved_vfp_registers)
+ * 2 * WORD)
+ if self.STACK_FIXED_AREA % 8 != 0:
+ self.STACK_FIXED_AREA += WORD # Stack alignment
+ assert self.STACK_FIXED_AREA % 8 == 0
def setup(self, looptoken, operations):
self.current_clt = looptoken.compiled_loop_token
@@ -105,21 +115,7 @@
# Addresses of functions called by new_xxx operations
gc_ll_descr = self.cpu.gc_ll_descr
gc_ll_descr.initialize()
- ll_new = gc_ll_descr.get_funcptr_for_new()
- self.malloc_func_addr = rffi.cast(lltype.Signed, ll_new)
self._build_propagate_exception_path()
- if gc_ll_descr.get_funcptr_for_newarray is not None:
- ll_new_array = gc_ll_descr.get_funcptr_for_newarray()
- self.malloc_array_func_addr = rffi.cast(lltype.Signed,
- ll_new_array)
- if gc_ll_descr.get_funcptr_for_newstr is not None:
- ll_new_str = gc_ll_descr.get_funcptr_for_newstr()
- self.malloc_str_func_addr = rffi.cast(lltype.Signed,
- ll_new_str)
- if gc_ll_descr.get_funcptr_for_newunicode is not None:
- ll_new_unicode = gc_ll_descr.get_funcptr_for_newunicode()
- self.malloc_unicode_func_addr = rffi.cast(lltype.Signed,
- ll_new_unicode)
if gc_ll_descr.get_malloc_slowpath_addr is not None:
self._build_malloc_slowpath()
if gc_ll_descr.gcrootmap and gc_ll_descr.gcrootmap.is_shadow_stack:
@@ -172,7 +168,8 @@
# call on_leave_jitted_save_exc()
# XXX add a check if cpu supports floats
with saved_registers(mc, r.caller_resp + [r.ip], r.caller_vfp_resp):
- addr = self.cpu.get_on_leave_jitted_int(save_exception=True)
+ addr = self.cpu.get_on_leave_jitted_int(save_exception=True,
+ default_to_memoryerror=True)
mc.BL(addr)
mc.gen_load_int(r.ip.value, self.cpu.propagate_exception_v)
mc.MOV_rr(r.r0.value, r.ip.value)
@@ -456,33 +453,36 @@
self.mc.writechar(chr(0))
def gen_func_epilog(self, mc=None, cond=c.AL):
+ stack_size = self.STACK_FIXED_AREA
+ stack_size -= len(r.callee_saved_registers) * WORD
+ if self.cpu.supports_floats:
+ stack_size -= len(r.callee_saved_vfp_registers) * 2 * WORD
+
gcrootmap = self.cpu.gc_ll_descr.gcrootmap
if mc is None:
mc = self.mc
if gcrootmap and gcrootmap.is_shadow_stack:
self.gen_footer_shadowstack(gcrootmap, mc)
- offset = 1
- if self.cpu.supports_floats:
- offset += 1 # to keep stack alignment
mc.MOV_rr(r.sp.value, r.fp.value, cond=cond)
- mc.ADD_ri(r.sp.value, r.sp.value,
- (N_REGISTERS_SAVED_BY_MALLOC + offset) * WORD, cond=cond)
+ mc.ADD_ri(r.sp.value, r.sp.value, stack_size, cond=cond)
if self.cpu.supports_floats:
mc.VPOP([reg.value for reg in r.callee_saved_vfp_registers],
cond=cond)
mc.POP([reg.value for reg in r.callee_restored_registers], cond=cond)
def gen_func_prolog(self):
+ stack_size = self.STACK_FIXED_AREA
+ stack_size -= len(r.callee_saved_registers) * WORD
+ if self.cpu.supports_floats:
+ stack_size -= len(r.callee_saved_vfp_registers) * 2 * WORD
+
self.mc.PUSH([reg.value for reg in r.callee_saved_registers])
- offset = 1
if self.cpu.supports_floats:
self.mc.VPUSH([reg.value for reg in r.callee_saved_vfp_registers])
- offset += 1 # to keep stack alignment
# here we modify the stack pointer to leave room for the 9 registers
# that are going to be saved here around malloc calls and one word to
# store the force index
- self.mc.SUB_ri(r.sp.value, r.sp.value,
- (N_REGISTERS_SAVED_BY_MALLOC + offset) * WORD)
+ self.mc.SUB_ri(r.sp.value, r.sp.value, stack_size)
self.mc.MOV_rr(r.fp.value, r.sp.value)
gcrootmap = self.cpu.gc_ll_descr.gcrootmap
if gcrootmap and gcrootmap.is_shadow_stack:
@@ -509,125 +509,6 @@
mc.SUB_ri(r.r5.value, r.r4.value, imm=2 * WORD) # ADD r5, r4 [2*WORD]
mc.STR_ri(r.r5.value, r.ip.value)
- def gen_bootstrap_code(self, arglocs, inputargs):
- nonfloatlocs, floatlocs = arglocs
- for i in range(len(nonfloatlocs)):
- loc = nonfloatlocs[i]
- if loc is None:
- continue
- arg = inputargs[i]
- assert arg.type != FLOAT
- if arg.type == REF:
- addr = self.fail_boxes_ptr.get_addr_for_num(i)
- elif arg.type == INT:
- addr = self.fail_boxes_int.get_addr_for_num(i)
- else:
- assert 0
- if loc.is_reg():
- reg = loc
- else:
- reg = r.ip
- self.mc.gen_load_int(reg.value, addr)
- self.mc.LDR_ri(reg.value, reg.value)
- if loc.is_stack():
- self.mov_loc_loc(r.ip, loc)
- for i in range(len(floatlocs)):
- loc = floatlocs[i]
- if loc is None:
- continue
- arg = inputargs[i]
- assert arg.type == FLOAT
- addr = self.fail_boxes_float.get_addr_for_num(i)
- self.mc.gen_load_int(r.ip.value, addr)
- if loc.is_vfp_reg():
- self.mc.VLDR(loc.value, r.ip.value)
- else:
- 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, arglocs, frame_depth, inputargs):
- self.gen_func_prolog()
- nonfloatlocs, floatlocs = arglocs
-
- reg_args = count_reg_args(inputargs)
-
- selected_reg = 0
- count = 0
- float_args = []
- nonfloat_args = []
- nonfloat_regs = []
- # load reg args
- for i in range(reg_args):
- arg = inputargs[i]
- if arg.type == FLOAT and count % 2 != 0:
- selected_reg += 1
- count = 0
- reg = r.all_regs[selected_reg]
-
- if arg.type == FLOAT:
- float_args.append((reg, floatlocs[i]))
- else:
- nonfloat_args.append(reg)
- nonfloat_regs.append(nonfloatlocs[i])
-
- if arg.type == FLOAT:
- selected_reg += 2
- else:
- selected_reg += 1
- count += 1
-
- # move float arguments to vfp regsiters
- for loc, vfp_reg in float_args:
- self.mov_to_vfp_loc(loc, r.all_regs[loc.value + 1], vfp_reg)
-
- # remap values stored in core registers
- remap_frame_layout(self, nonfloat_args, nonfloat_regs, r.ip)
-
- # load values passed on the stack to the corresponding locations
- stack_position = len(r.callee_saved_registers) * WORD + \
- len(r.callee_saved_vfp_registers) * 2 * WORD + \
- N_REGISTERS_SAVED_BY_MALLOC * WORD + \
- 2 * WORD # for the FAIL INDEX and the stack padding
- count = 0
- for i in range(reg_args, len(inputargs)):
- arg = inputargs[i]
- if arg.type == FLOAT:
- loc = floatlocs[i]
- else:
- loc = nonfloatlocs[i]
- if loc.is_reg():
- self.mc.LDR_ri(loc.value, r.fp.value, stack_position)
- count += 1
- elif loc.is_vfp_reg():
- if count % 2 != 0:
- stack_position += WORD
- count = 0
- self.mc.VLDR(loc.value, r.fp.value, stack_position)
- elif loc.is_stack():
- if loc.type == FLOAT:
- if count % 2 != 0:
- stack_position += WORD
- count = 0
- self.mc.VLDR(r.vfp_ip.value, r.fp.value, stack_position)
- self.mov_loc_loc(r.vfp_ip, loc)
- elif loc.type == INT or loc.type == REF:
- count += 1
- self.mc.LDR_ri(r.ip.value, r.fp.value, stack_position)
- self.mov_loc_loc(r.ip, loc)
- else:
- assert 0, 'invalid location'
- else:
- assert 0, 'invalid location'
- if loc.type == FLOAT:
- size = 2
- else:
- size = 1
- stack_position += size * WORD
-
- sp_patch_location = self._prepare_sp_patch_position()
- self.mc.B_offs(loop_head)
- self._patch_sp_offset(sp_patch_location, frame_depth)
-
def _dump(self, ops, type='loop'):
debug_start('jit-backend-ops')
debug_print(type)
@@ -635,11 +516,16 @@
debug_print(op.repr())
debug_stop('jit-backend-ops')
+ def _call_header(self):
+ self.align()
+ self.gen_func_prolog()
+
# cpu interface
def assemble_loop(self, inputargs, operations, looptoken, log):
clt = CompiledLoopToken(self.cpu, looptoken.number)
clt.allgcrefs = []
looptoken.compiled_loop_token = clt
+ clt._debug_nbargs = len(inputargs)
if not we_are_translated():
# Arguments should be unique
@@ -648,37 +534,24 @@
operations = self.setup(looptoken, operations)
self._dump(operations)
- self.align()
- self.gen_func_prolog()
+ self._call_header()
sp_patch_location = self._prepare_sp_patch_position()
regalloc = Regalloc(assembler=self, frame_manager=ARMFrameManager())
- arglocs = regalloc.prepare_loop(inputargs, operations)
- self.gen_bootstrap_code(arglocs, inputargs)
- looptoken._arm_arglocs = arglocs
+ regalloc.prepare_loop(inputargs, operations)
+
loop_head = self.mc.currpos()
-
looptoken._arm_loop_code = loop_head
- looptoken._arm_bootstrap_code = 0
clt.frame_depth = -1
frame_depth = self._assemble(operations, regalloc)
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, arglocs,
- frame_depth, inputargs)
-
self.write_pending_failure_recoveries()
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
+ looptoken._arm_func_addr = rawstart
self.process_pending_guards(rawstart)
self.fixup_target_tokens(rawstart)
@@ -692,11 +565,13 @@
def _assemble(self, operations, regalloc):
regalloc.compute_hint_frame_locations(operations)
+ #self.mc.BKPT()
self._walk_operations(operations, regalloc)
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_clt.frame_depth)
+ frame_depth = max(frame_depth,
+ jump_target_descr._arm_clt.frame_depth)
return frame_depth
def assemble_bridge(self, faildescr, inputargs, operations,
@@ -735,7 +610,8 @@
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.current_clt.frame_depth = max(self.current_clt.frame_depth,
+ frame_depth)
self.teardown()
def fixup_target_tokens(self, rawstart):
@@ -1161,7 +1037,8 @@
llop.gc_assume_young_pointers(lltype.Void,
llmemory.cast_ptr_to_adr(ptrs))
- def malloc_cond(self, nursery_free_adr, nursery_top_adr, size, tid):
+ def malloc_cond(self, nursery_free_adr, nursery_top_adr, size):
+ assert size & (WORD-1) == 0 # must be correctly aligned
size = max(size, self.cpu.gc_ll_descr.minimal_size_in_nursery)
size = (size + WORD - 1) & ~(WORD - 1) # round up
@@ -1205,9 +1082,6 @@
self.mc.gen_load_int(r.ip.value, nursery_free_adr)
self.mc.STR_ri(r.r1.value, r.ip.value)
- self.mc.gen_load_int(r.ip.value, tid)
- self.mc.STR_ri(r.ip.value, r.r0.value)
-
def mark_gc_roots(self, force_index, use_copy_area=False):
if force_index < 0:
return # not needed
diff --git a/pypy/jit/backend/arm/jump.py b/pypy/jit/backend/arm/jump.py
--- a/pypy/jit/backend/arm/jump.py
+++ b/pypy/jit/backend/arm/jump.py
@@ -1,6 +1,5 @@
# ../x86/jump.py
# XXX combine with ../x86/jump.py and move to llsupport
-import sys
def remap_frame_layout(assembler, src_locations, dst_locations, tmpreg):
@@ -18,7 +17,10 @@
key = src.as_key()
if key in srccount:
if key == dst_locations[i].as_key():
- srccount[key] = -sys.maxint # ignore a move "x = x"
+ # ignore a move "x = x"
+ # setting any "large enough" negative value is ok, but
+ # be careful of overflows, don't use -sys.maxint
+ srccount[key] = -len(dst_locations) - 1
pending_dests -= 1
else:
srccount[key] += 1
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
@@ -305,9 +305,17 @@
_mixin_ = True
def emit_op_jump(self, op, arglocs, regalloc, fcond):
+ # 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, TargetToken)
assert fcond == c.AL
+ my_nbargs = self.current_clt._debug_nbargs
+ target_nbargs = descr._arm_clt._debug_nbargs
+ assert my_nbargs == target_nbargs
self._insert_checks()
if descr in self.target_tokens_currently_compiling:
@@ -376,7 +384,7 @@
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)
+ size = descr.get_result_size()
signed = descr.is_result_signed()
self._ensure_result_bit_extension(loc, size, signed)
return cond
@@ -786,7 +794,7 @@
#XXX Hack, Hack, Hack
if not we_are_translated():
descr = op.getdescr()
- size = descr.get_item_size(False)
+ size = descr.itemsize
signed = descr.is_item_signed()
self._ensure_result_bit_extension(res, size, signed)
return fcond
@@ -1000,9 +1008,9 @@
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
# XXX check this
- assert op.numargs() == len(descr._arm_arglocs[0])
+ # assert len(arglocs) - 2 == descr.compiled_loop_token._debug_nbargs
resbox = TempInt()
- self._emit_call(fail_index, descr._arm_direct_bootstrap_code,
+ self._emit_call(fail_index, descr._arm_func_addr,
op.getarglist(), regalloc, fcond, result=resbox)
if op.result is None:
value = self.cpu.done_with_this_frame_void_v
@@ -1059,9 +1067,9 @@
# Reset the vable token --- XXX really too much special logic here:-(
if jd.index_of_virtualizable >= 0:
- from pypy.jit.backend.llsupport.descr import BaseFieldDescr
+ from pypy.jit.backend.llsupport.descr import FieldDescr
fielddescr = jd.vable_token_descr
- assert isinstance(fielddescr, BaseFieldDescr)
+ assert isinstance(fielddescr, FieldDescr)
ofs = fielddescr.offset
resloc = regalloc.force_allocate_reg(resbox)
self.mov_loc_loc(arglocs[1], r.ip)
@@ -1103,11 +1111,15 @@
# ../x86/assembler.py:668
def redirect_call_assembler(self, oldlooptoken, newlooptoken):
- # we overwrite the instructions at the old _x86_direct_bootstrap_code
- # to start with a JMP to the new _arm_direct_bootstrap_code.
+ # some minimal sanity checking
+ old_nbargs = oldlooptoken.compiled_loop_token._debug_nbargs
+ new_nbargs = newlooptoken.compiled_loop_token._debug_nbargs
+ assert old_nbargs == new_nbargs
+ # we overwrite the instructions at the old _arm_func_adddr
+ # to start with a JMP to the new _arm_func_addr.
# Ideally we should rather patch all existing CALLs, but well.
- oldadr = oldlooptoken._arm_direct_bootstrap_code
- target = newlooptoken._arm_direct_bootstrap_code
+ oldadr = oldlooptoken._arm_func_addr
+ target = newlooptoken._arm_func_addr
mc = ARMv7Builder()
mc.B(target)
mc.copy_to_raw_memory(oldadr)
@@ -1191,36 +1203,10 @@
self._emit_call(force_index, self.malloc_func_addr, [size_box],
regalloc, result=result)
- def emit_op_new(self, op, arglocs, regalloc, fcond):
+ def emit_op_call_malloc_gc(self, op, arglocs, regalloc, fcond):
self.propagate_memoryerror_if_r0_is_null()
return fcond
- def emit_op_new_with_vtable(self, op, arglocs, regalloc, fcond):
- classint = arglocs[0].value
- self.set_vtable(op.result, classint)
- return fcond
-
- def set_vtable(self, box, vtable):
- if self.cpu.vtable_offset is not None:
- adr = rffi.cast(lltype.Signed, vtable)
- self.mc.gen_load_int(r.ip.value, adr)
- self.mc.STR_ri(r.ip.value, r.r0.value, self.cpu.vtable_offset)
-
- def set_new_array_length(self, loc, ofs_length, loc_num_elem):
- assert loc.is_reg()
- self.mc.gen_load_int(r.ip.value, loc_num_elem)
- self.mc.STR_ri(r.ip.value, loc.value, imm=ofs_length)
-
- def emit_op_new_array(self, op, arglocs, regalloc, fcond):
- self.propagate_memoryerror_if_r0_is_null()
- if len(arglocs) > 0:
- value_loc, base_loc, ofs_length = arglocs
- self.mc.STR_ri(value_loc.value, base_loc.value, ofs_length.value)
- return fcond
-
- emit_op_newstr = emit_op_new_array
- emit_op_newunicode = emit_op_new_array
-
class FloatOpAssemlber(object):
_mixin_ = True
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
@@ -12,26 +12,27 @@
check_imm_box
)
from pypy.jit.backend.arm.jump import remap_frame_layout_mixed
-from pypy.jit.backend.arm.arch import MY_COPY_OF_REGS, WORD
+from pypy.jit.backend.arm.arch import MY_COPY_OF_REGS
+from pypy.jit.backend.arm.arch import WORD, N_REGISTERS_SAVED_BY_MALLOC
from pypy.jit.codewriter import longlong
from pypy.jit.metainterp.history import (Const, ConstInt, ConstFloat, ConstPtr,
Box, BoxPtr,
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
+from pypy.jit.backend.llsupport.descr import ArrayDescr
from pypy.jit.backend.llsupport import symbolic
from pypy.rpython.lltypesystem import lltype, rffi, rstr
-from pypy.jit.codewriter import heaptracker
from pypy.jit.codewriter.effectinfo import EffectInfo
+from pypy.jit.backend.llsupport.descr import unpack_arraydescr
+from pypy.jit.backend.llsupport.descr import unpack_fielddescr
+from pypy.jit.backend.llsupport.descr import unpack_interiorfielddescr
# 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
@@ -65,9 +66,11 @@
def frame_pos(loc, type):
num_words = ARMFrameManager.frame_size(type)
if type == FLOAT:
- # Make sure that loc is an even value
- # the frame layout requires loc to be even!!
- assert (loc & 1) == 0
+ if loc > 0:
+ # Make sure that loc is an even value
+ # the frame layout requires loc to be even if it is a spilled
+ # value!!
+ assert (loc & 1) == 0
return locations.StackLocation(loc + 1,
num_words=num_words, type=type)
return locations.StackLocation(loc, num_words=num_words, type=type)
@@ -118,8 +121,8 @@
if isinstance(thing, Const):
assert isinstance(thing, ConstFloat)
loc = self.get_scratch_reg(FLOAT, self.temp_boxes + forbidden_vars)
- imm = self.convert_to_imm(thing)
- self.assembler.load(loc, imm)
+ immvalue = self.convert_to_imm(thing)
+ self.assembler.load(loc, immvalue)
else:
loc = self.make_sure_var_in_reg(thing,
forbidden_vars=self.temp_boxes + forbidden_vars)
@@ -161,7 +164,8 @@
def convert_to_imm(self, c):
if isinstance(c, ConstInt):
- return locations.ImmLocation(c.value)
+ val = rffi.cast(rffi.INT, c.value)
+ return locations.ImmLocation(val)
else:
assert isinstance(c, ConstPtr)
return locations.ImmLocation(rffi.cast(lltype.Signed, c.value))
@@ -176,8 +180,8 @@
tp = INT
loc = self.get_scratch_reg(tp, forbidden_vars=self.temp_boxes
+ forbidden_vars)
- imm = self.convert_to_imm(thing)
- self.assembler.load(loc, imm)
+ immvalue = self.convert_to_imm(thing)
+ self.assembler.load(loc, immvalue)
else:
loc = self.make_sure_var_in_reg(thing,
forbidden_vars=forbidden_vars)
@@ -297,39 +301,63 @@
return self.vfprm.convert_to_imm(value)
def _prepare(self, inputargs, operations):
- longevity, useful = compute_vars_longevity(inputargs, operations)
+ longevity, last_real_usage = compute_vars_longevity(
+ inputargs, operations)
self.longevity = longevity
+ self.last_real_usage = last_real_usage
fm = self.frame_manager
asm = self.assembler
self.vfprm = VFPRegisterManager(longevity, fm, asm)
self.rm = ARMv7RegisterManager(longevity, fm, asm)
- return useful
def prepare_loop(self, inputargs, operations):
- useful = self._prepare(inputargs, operations)
- return self._process_inputargs(inputargs, useful)
+ self._prepare(inputargs, operations)
+ self._set_initial_bindings(inputargs)
+ self.possibly_free_vars(list(inputargs))
def prepare_bridge(self, inputargs, arglocs, ops):
self._prepare(inputargs, ops)
self._update_bindings(arglocs, inputargs)
- def _process_inputargs(self, inputargs, useful):
- floatlocs = [None] * len(inputargs)
- nonfloatlocs = [None] * len(inputargs)
- for i in range(len(inputargs)):
- arg = inputargs[i]
- assert not isinstance(arg, Const)
- loc = inputargs[i]
- if self.longevity[arg][1] > -1 and arg in useful:
- self.try_allocate_reg(loc)
+ def _set_initial_bindings(self, inputargs):
+ # The first inputargs are passed in registers r0-r3
+ # we relly on the soft-float calling convention so we need to move
+ # float params to the coprocessor.
- loc = self.loc(arg)
- if arg.type == FLOAT:
- floatlocs[i] = loc
+ arg_index = 0
+ count = 0
+ n_register_args = len(r.argument_regs)
+ cur_frame_pos = - (self.assembler.STACK_FIXED_AREA / WORD) + 1
+ for box in inputargs:
+ assert isinstance(box, Box)
+ # handle inputargs in argument registers
+ if box.type == FLOAT and arg_index % 2 != 0:
+ arg_index += 1 # align argument index for float passed
+ # in register
+ if arg_index < n_register_args:
+ if box.type == FLOAT:
+ loc = r.argument_regs[arg_index]
+ loc2 = r.argument_regs[arg_index + 1]
+ vfpreg = self.try_allocate_reg(box)
+ # move soft-float argument to vfp
+ self.assembler.mov_to_vfp_loc(loc, loc2, vfpreg)
+ arg_index += 2 # this argument used to argument registers
+ else:
+ loc = r.argument_regs[arg_index]
+ self.try_allocate_reg(box, selected_reg=loc)
+ arg_index += 1
else:
- nonfloatlocs[i] = loc
- self.possibly_free_vars(list(inputargs))
- return nonfloatlocs, floatlocs
+ # treat stack args as stack locations with a negative offset
+ if box.type == FLOAT:
+ cur_frame_pos -= 2
+ if count % 2 != 0: # Stack argument alignment
+ cur_frame_pos -= 1
+ count = 0
+ else:
+ cur_frame_pos -= 1
+ count += 1
+ loc = self.frame_manager.frame_pos(cur_frame_pos, box.type)
+ self.frame_manager.set_binding(box, loc)
def _update_bindings(self, locs, inputargs):
used = {}
@@ -533,6 +561,10 @@
args = [imm(rffi.cast(lltype.Signed, op.getarg(0).getint()))]
return args
+ def prepare_op_call_malloc_gc(self, op, fcond):
+ args = [imm(rffi.cast(lltype.Signed, op.getarg(0).getint()))]
+ return args
+
def _prepare_guard(self, op, args=None):
if args is None:
args = []
@@ -651,41 +683,45 @@
# 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)
+ arglocs = self.assembler.target_arglocs(descr)
jump_op = self.final_jump_op
+ assert len(arglocs) == jump_op.numargs()
for i in range(jump_op.numargs()):
box = jump_op.getarg(i)
if isinstance(box, Box):
- loc = nonfloatlocs[i]
+ loc = arglocs[i]
if loc is not None and loc.is_stack():
- assert box.type != FLOAT
self.frame_manager.hint_frame_locations[box] = loc
- else:
- loc = floatlocs[i]
- if loc is not None and loc.is_stack():
- assert box.type == FLOAT
- self.frame_manager.hint_frame_locations[box] = loc
def prepare_op_jump(self, op, fcond):
descr = op.getdescr()
assert isinstance(descr, TargetToken)
self.jump_target_descr = descr
- nonfloatlocs, floatlocs = self.assembler.target_arglocs(descr)
+ arglocs = self.assembler.target_arglocs(descr)
# get temporary locs
tmploc = r.ip
vfptmploc = r.vfp_ip
# Part about non-floats
- # XXX we don't need a copy, we only just the original list
- src_locations1 = [self.loc(op.getarg(i)) for i in range(op.numargs())
- if op.getarg(i).type != FLOAT]
- assert tmploc not in nonfloatlocs
- dst_locations1 = [loc for loc in nonfloatlocs if loc is not None]
+ src_locations1 = []
+ dst_locations1 = []
# Part about floats
- src_locations2 = [self.loc(op.getarg(i)) for i in range(op.numargs())
- if op.getarg(i).type == FLOAT]
- dst_locations2 = [loc for loc in floatlocs if loc is not None]
+ src_locations2 = []
+ dst_locations2 = []
+
+ # 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:
+ src_locations2.append(src_loc)
+ dst_locations2.append(dst_loc)
+
remap_frame_layout_mixed(self.assembler,
src_locations1, dst_locations1, tmploc,
src_locations2, dst_locations2, vfptmploc)
@@ -694,7 +730,7 @@
def prepare_op_setfield_gc(self, op, fcond):
boxes = list(op.getarglist())
a0, a1 = boxes
- ofs, size, ptr = self._unpack_fielddescr(op.getdescr())
+ ofs, size, sign = unpack_fielddescr(op.getdescr())
base_loc = self._ensure_value_is_boxed(a0, boxes)
value_loc = self._ensure_value_is_boxed(a1, boxes)
if check_imm_arg(ofs):
@@ -708,7 +744,7 @@
def prepare_op_getfield_gc(self, op, fcond):
a0 = op.getarg(0)
- ofs, size, ptr = self._unpack_fielddescr(op.getdescr())
+ ofs, size, sign = unpack_fielddescr(op.getdescr())
base_loc = self._ensure_value_is_boxed(a0)
immofs = imm(ofs)
if check_imm_arg(ofs):
@@ -726,7 +762,7 @@
prepare_op_getfield_gc_pure = prepare_op_getfield_gc
def prepare_op_getinteriorfield_gc(self, op, fcond):
- t = self._unpack_interiorfielddescr(op.getdescr())
+ t = unpack_interiorfielddescr(op.getdescr())
ofs, itemsize, fieldsize, sign = t
args = op.getarglist()
base_loc = self._ensure_value_is_boxed(op.getarg(0), args)
@@ -744,7 +780,7 @@
imm(itemsize), imm(fieldsize)]
def prepare_op_setinteriorfield_gc(self, op, fcond):
- t = self._unpack_interiorfielddescr(op.getdescr())
+ t = unpack_interiorfielddescr(op.getdescr())
ofs, itemsize, fieldsize, sign = t
args = op.getarglist()
base_loc = self._ensure_value_is_boxed(op.getarg(0), args)
@@ -761,8 +797,8 @@
def prepare_op_arraylen_gc(self, op, fcond):
arraydescr = op.getdescr()
- assert isinstance(arraydescr, BaseArrayDescr)
- ofs = arraydescr.get_ofs_length(self.cpu.translate_support_code)
+ assert isinstance(arraydescr, ArrayDescr)
+ ofs = arraydescr.lendescr.offset
arg = op.getarg(0)
base_loc = self._ensure_value_is_boxed(arg)
self.possibly_free_vars_for_op(op)
@@ -772,27 +808,27 @@
def prepare_op_setarrayitem_gc(self, op, fcond):
a0, a1, a2 = list(op.getarglist())
- _, scale, base_ofs, _, ptr = self._unpack_arraydescr(op.getdescr())
-
+ size, ofs, _ = unpack_arraydescr(op.getdescr())
+ scale = get_scale(size)
args = op.getarglist()
base_loc = self._ensure_value_is_boxed(a0, args)
ofs_loc = self._ensure_value_is_boxed(a1, args)
value_loc = self._ensure_value_is_boxed(a2, args)
- assert check_imm_arg(base_ofs)
- return [value_loc, base_loc, ofs_loc, imm(scale), imm(base_ofs)]
+ assert check_imm_arg(ofs)
+ return [value_loc, base_loc, ofs_loc, imm(scale), imm(ofs)]
prepare_op_setarrayitem_raw = prepare_op_setarrayitem_gc
def prepare_op_getarrayitem_gc(self, op, fcond):
a0, a1 = boxes = list(op.getarglist())
- _, scale, base_ofs, _, ptr = self._unpack_arraydescr(op.getdescr())
-
+ size, ofs, _ = unpack_arraydescr(op.getdescr())
+ scale = get_scale(size)
base_loc = self._ensure_value_is_boxed(a0, boxes)
ofs_loc = self._ensure_value_is_boxed(a1, boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- assert check_imm_arg(base_ofs)
- return [res, base_loc, ofs_loc, imm(scale), imm(base_ofs)]
+ assert check_imm_arg(ofs)
+ return [res, base_loc, ofs_loc, imm(scale), imm(ofs)]
prepare_op_getarrayitem_raw = prepare_op_getarrayitem_gc
prepare_op_getarrayitem_gc_pure = prepare_op_getarrayitem_gc
@@ -906,86 +942,22 @@
prepare_op_cast_ptr_to_int = prepare_op_same_as
prepare_op_cast_int_to_ptr = prepare_op_same_as
- def prepare_op_new(self, op, fcond):
- gc_ll_descr = self.assembler.cpu.gc_ll_descr
- if gc_ll_descr.can_inline_malloc(op.getdescr()):
- self.fastpath_malloc_fixedsize(op, op.getdescr())
- else:
- arglocs = self._prepare_args_for_new_op(op.getdescr())
- force_index = self.assembler.write_new_force_index()
- self.assembler._emit_call(force_index,
- self.assembler.malloc_func_addr, arglocs,
- self, fcond, result=op.result)
- self.possibly_free_vars(arglocs)
- self.possibly_free_var(op.result)
- return []
+ def prepare_op_call_malloc_nursery(self, op, fcond):
+ size_box = op.getarg(0)
+ assert isinstance(size_box, ConstInt)
+ size = size_box.getint()
- def prepare_op_new_with_vtable(self, op, fcond):
- classint = op.getarg(0).getint()
- descrsize = heaptracker.vtable2descr(self.cpu, classint)
- if self.assembler.cpu.gc_ll_descr.can_inline_malloc(descrsize):
- self.fastpath_malloc_fixedsize(op, descrsize)
- else:
- callargs = self._prepare_args_for_new_op(descrsize)
- force_index = self.assembler.write_new_force_index()
- self.assembler._emit_call(force_index,
- self.assembler.malloc_func_addr, callargs,
- self, fcond, result=op.result)
- self.possibly_free_vars(callargs)
- self.possibly_free_var(op.result)
- return [imm(classint)]
-
- def prepare_op_new_array(self, op, fcond):
- gc_ll_descr = self.cpu.gc_ll_descr
- if gc_ll_descr.get_funcptr_for_newarray is not None:
- # framework GC
- box_num_elem = op.getarg(0)
- if isinstance(box_num_elem, ConstInt):
- num_elem = box_num_elem.value
- if gc_ll_descr.can_inline_malloc_varsize(op.getdescr(),
- num_elem):
- self.fastpath_malloc_varsize(op, op.getdescr(), num_elem)
- return []
- args = self.assembler.cpu.gc_ll_descr.args_for_new_array(
- op.getdescr())
- argboxes = [ConstInt(x) for x in args]
- argboxes.append(box_num_elem)
- force_index = self.assembler.write_new_force_index()
- self.assembler._emit_call(force_index,
- self.assembler.malloc_array_func_addr, argboxes, self,
- fcond, result=op.result)
- return []
- # boehm GC
- itemsize, scale, basesize, ofs_length, _ = (
- self._unpack_arraydescr(op.getdescr()))
- return self._malloc_varsize(basesize, ofs_length, itemsize, op)
-
- def fastpath_malloc_varsize(self, op, arraydescr, num_elem):
- assert isinstance(arraydescr, BaseArrayDescr)
- ofs_length = arraydescr.get_ofs_length(self.cpu.translate_support_code)
- basesize = arraydescr.get_base_size(self.cpu.translate_support_code)
- itemsize = arraydescr.get_item_size(self.cpu.translate_support_code)
- size = basesize + itemsize * num_elem
- self._do_fastpath_malloc(op, size, arraydescr.tid)
- # we know the resullt of the malloc call is in r0
- self.assembler.set_new_array_length(r.r0, ofs_length, num_elem)
-
- def fastpath_malloc_fixedsize(self, op, descr):
- assert isinstance(descr, BaseSizeDescr)
- self._do_fastpath_malloc(op, descr.size, descr.tid)
-
- def _do_fastpath_malloc(self, op, size, tid):
- gc_ll_descr = self.assembler.cpu.gc_ll_descr
self.rm.force_allocate_reg(op.result, selected_reg=r.r0)
t = TempInt()
self.rm.force_allocate_reg(t, selected_reg=r.r1)
self.possibly_free_var(op.result)
self.possibly_free_var(t)
+ gc_ll_descr = self.assembler.cpu.gc_ll_descr
self.assembler.malloc_cond(
gc_ll_descr.get_nursery_free_addr(),
gc_ll_descr.get_nursery_top_addr(),
- size, tid,
+ size
)
def get_mark_gc_roots(self, gcrootmap, use_copy_area=False):
@@ -1007,59 +979,6 @@
return gcrootmap.compress_callshape(shape,
self.assembler.datablockwrapper)
- def prepare_op_newstr(self, op, fcond):
- gc_ll_descr = self.cpu.gc_ll_descr
- if gc_ll_descr.get_funcptr_for_newstr is not None:
- force_index = self.assembler.write_new_force_index()
- self.assembler._emit_call(force_index,
- self.assembler.malloc_str_func_addr, [op.getarg(0)],
- self, fcond, op.result)
- return []
- # boehm GC
- ofs_items, itemsize, ofs = symbolic.get_array_token(rstr.STR,
- self.cpu.translate_support_code)
- assert itemsize == 1
- return self._malloc_varsize(ofs_items, ofs, itemsize, op)
-
- def prepare_op_newunicode(self, op, fcond):
- gc_ll_descr = self.cpu.gc_ll_descr
- if gc_ll_descr.get_funcptr_for_newunicode is not None:
- force_index = self.assembler.write_new_force_index()
- self.assembler._emit_call(force_index,
- self.assembler.malloc_unicode_func_addr,
- [op.getarg(0)], self, fcond, op.result)
- return []
- # boehm GC
- ofs_items, _, ofs = symbolic.get_array_token(rstr.UNICODE,
- self.cpu.translate_support_code)
- _, itemsize, _ = symbolic.get_array_token(rstr.UNICODE,
- self.cpu.translate_support_code)
- return self._malloc_varsize(ofs_items, ofs, itemsize, op)
-
- def _malloc_varsize(self, ofs_items, ofs_length, itemsize, op):
- v = op.getarg(0)
- res_v = op.result
- boxes = [v, res_v]
- immofs = imm(ofs_items)
- if check_imm_arg(ofs_items):
- ofs_items_loc = immofs
- else:
- ofs_items_loc = self.get_scratch_reg(INT, boxes)
- self.assembler.load(ofs_items_loc, immofs)
- vloc = self._ensure_value_is_boxed(v, [res_v])
-
- size = self.get_scratch_reg(INT, boxes)
- self.assembler.load(itemsize)
-
- self.assembler._regalloc_malloc_varsize(size, size_box,
- vloc, vbox, ofs_items_loc, self, res_v)
- base_loc = self.make_sure_var_in_reg(res_v)
-
- value_loc = self._ensure_value_is_boxed(v, [res_v])
- assert value_loc.is_reg()
- assert base_loc.is_reg()
- return [value_loc, base_loc, imm(ofs_length)]
-
prepare_op_debug_merge_point = void
prepare_op_jit_debug = void
@@ -1088,20 +1007,28 @@
descr = op.getdescr()
assert isinstance(descr, TargetToken)
inputargs = op.getarglist()
- floatlocs = [None] * len(inputargs)
- nonfloatlocs = [None] * len(inputargs)
+ 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 not isinstance(arg, Const)
+ assert isinstance(arg, Box)
loc = self.loc(arg)
- if arg.type == FLOAT:
- floatlocs[i] = loc
- else:
- nonfloatlocs[i] = loc
+ arglocs[i] = loc
if loc.is_reg():
self.frame_manager.mark_as_free(arg)
- descr._arm_arglocs = nonfloatlocs, floatlocs
+ #
+ descr._arm_arglocs = arglocs
descr._arm_loop_code = self.assembler.mc.currpos()
descr._arm_clt = self.assembler.current_clt
self.assembler.target_tokens_currently_compiling[descr] = None
@@ -1114,7 +1041,6 @@
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()
@@ -1159,8 +1085,7 @@
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
assert jd is not None
- size = jd.portal_calldescr.get_result_size(
- self.cpu.translate_support_code)
+ size = jd.portal_calldescr.get_result_size()
vable_index = jd.index_of_virtualizable
if vable_index >= 0:
self._sync_var(op.getarg(vable_index))
@@ -1182,40 +1107,6 @@
arglocs.append(t)
return arglocs
- # from ../x86/regalloc.py:791
- def _unpack_fielddescr(self, fielddescr):
- assert isinstance(fielddescr, BaseFieldDescr)
- ofs = fielddescr.offset
- size = fielddescr.get_field_size(self.cpu.translate_support_code)
- ptr = fielddescr.is_pointer_field()
- return ofs, size, ptr
-
- # from ../x86/regalloc.py:779
- def _unpack_arraydescr(self, arraydescr):
- assert isinstance(arraydescr, BaseArrayDescr)
- cpu = self.cpu
- ofs_length = arraydescr.get_ofs_length(cpu.translate_support_code)
- ofs = arraydescr.get_base_size(cpu.translate_support_code)
- size = arraydescr.get_item_size(cpu.translate_support_code)
- ptr = arraydescr.is_array_of_pointers()
- scale = 0
- while (1 << scale) < size:
- scale += 1
- assert (1 << scale) == size
- return size, scale, ofs, ofs_length, ptr
-
- # from ../x86/regalloc.py:965
- def _unpack_interiorfielddescr(self, descr):
- assert isinstance(descr, InteriorFieldDescr)
- arraydescr = descr.arraydescr
- ofs = arraydescr.get_base_size(self.cpu.translate_support_code)
- itemsize = arraydescr.get_item_size(self.cpu.translate_support_code)
- fieldsize = descr.fielddescr.get_field_size(
- self.cpu.translate_support_code)
- sign = descr.fielddescr.is_field_signed()
- ofs += descr.fielddescr.offset
- return ofs, itemsize, fieldsize, sign
-
prepare_op_float_add = prepare_float_op(name='prepare_op_float_add')
prepare_op_float_sub = prepare_float_op(name='prepare_op_float_sub')
prepare_op_float_mul = prepare_float_op(name='prepare_op_float_mul')
@@ -1294,6 +1185,14 @@
operations = [notimplemented] * (rop._LAST + 1)
operations_with_guard = [notimplemented_with_guard] * (rop._LAST + 1)
+
+def get_scale(size):
+ scale = 0
+ while (1 << scale) < size:
+ scale += 1
+ assert (1 << scale) == size
+ return scale
+
for key, value in rop.__dict__.items():
key = key.lower()
if key.startswith('_'):
diff --git a/pypy/jit/backend/arm/registers.py b/pypy/jit/backend/arm/registers.py
--- a/pypy/jit/backend/arm/registers.py
+++ b/pypy/jit/backend/arm/registers.py
@@ -21,7 +21,7 @@
all_regs = [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10]
all_vfp_regs = vfpregisters[:-1]
-caller_resp = [r0, r1, r2, r3]
+argument_regs = caller_resp = [r0, r1, r2, r3]
callee_resp = [r4, r5, r6, r7, r8, r9, r10, fp]
callee_saved_registers = callee_resp + [lr]
callee_restored_registers = callee_resp + [pc]
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
@@ -9,7 +9,6 @@
class ArmCPU(AbstractLLCPU):
- BOOTSTRAP_TP = lltype.FuncType([], lltype.Signed)
supports_floats = True
def __init__(self, rtyper, stats, opts=None, translate_support_code=False,
@@ -47,15 +46,6 @@
self.assembler.assemble_bridge(faildescr, inputargs, operations,
original_loop_token, log=log)
- def set_future_value_float(self, index, floatvalue):
- self.assembler.fail_boxes_float.setitem(index, floatvalue)
-
- def set_future_value_int(self, index, intvalue):
- self.assembler.fail_boxes_int.setitem(index, intvalue)
-
- def set_future_value_ref(self, index, ptrvalue):
- self.assembler.fail_boxes_ptr.setitem(index, ptrvalue)
-
def get_latest_value_float(self, index):
return self.assembler.fail_boxes_float.getitem(index)
@@ -80,27 +70,29 @@
for index in range(count):
setitem(index, null)
- def execute_token(self, executable_token):
- #i = [self.get_latest_value_int(x) for x in range(10)]
- #print 'Inputargs: %r for token %r' % (i, executable_token)
- addr = executable_token._arm_bootstrap_code
- assert addr % 8 == 0
- func = rffi.cast(lltype.Ptr(self.BOOTSTRAP_TP), addr)
- fail_index = self._execute_call(func)
- return self.get_fail_descr_from_number(fail_index)
+ def make_execute_token(self, *ARGS):
+ FUNCPTR = lltype.Ptr(lltype.FuncType(ARGS, lltype.Signed))
- def _execute_call(self, func):
- prev_interpreter = None
- if not self.translate_support_code:
- prev_interpreter = LLInterpreter.current_interpreter
- LLInterpreter.current_interpreter = self.debug_ll_interpreter
- res = 0
- try:
- res = func()
- finally:
+ def execute_token(executable_token, *args):
+ clt = executable_token.compiled_loop_token
+ assert len(args) == clt._debug_nbargs
+ #
+ addr = executable_token._arm_func_addr
+ assert addr % 8 == 0
+ func = rffi.cast(FUNCPTR, addr)
+ #llop.debug_print(lltype.Void, ">>>> Entering", addr)
+ prev_interpreter = None # help flow space
if not self.translate_support_code:
- LLInterpreter.current_interpreter = prev_interpreter
- return res
+ prev_interpreter = LLInterpreter.current_interpreter
+ LLInterpreter.current_interpreter = self.debug_ll_interpreter
+ try:
+ fail_index = func(*args)
+ finally:
+ if not self.translate_support_code:
+ LLInterpreter.current_interpreter = prev_interpreter
+ #llop.debug_print(lltype.Void, "<<<< Back")
+ return self.get_fail_descr_from_number(fail_index)
+ return execute_token
def cast_ptr_to_int(x):
adr = llmemory.cast_ptr_to_adr(x)
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
@@ -32,9 +32,8 @@
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
- for x in range(11):
- self.cpu.set_future_value_int(x, x)
- self.cpu.execute_token(looptoken)
+ args = [x for x in range(11)]
+ self.cpu.execute_token(looptoken, *args)
for x in range(11):
assert self.cpu.get_latest_value_int(x) == x
assert self.cpu.get_latest_value_int(11) == 38
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
@@ -43,17 +43,8 @@
looptoken = JitCellToken()
operations[2].setfailargs([v12, v8, v3, v2, v1, v11])
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -12)
- cpu.set_future_value_int(1, -26)
- cpu.set_future_value_int(2, -19)
- cpu.set_future_value_int(3, 7)
- cpu.set_future_value_int(4, -5)
- cpu.set_future_value_int(5, -24)
- cpu.set_future_value_int(6, -37)
- cpu.set_future_value_int(7, 62)
- cpu.set_future_value_int(8, 9)
- cpu.set_future_value_int(9, 12)
- op = cpu.execute_token(looptoken)
+ args = [-12 , -26 , -19 , 7 , -5 , -24 , -37 , 62 , 9 , 12]
+ op = cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == 0
assert cpu.get_latest_value_int(1) == 62
assert cpu.get_latest_value_int(2) == -19
@@ -103,17 +94,8 @@
operations[9].setfailargs([v15, v7, v10, v18, v4, v17, v1])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 16)
- cpu.set_future_value_int(1, 5)
- cpu.set_future_value_int(2, 5)
- cpu.set_future_value_int(3, 16)
- cpu.set_future_value_int(4, 46)
- cpu.set_future_value_int(5, 6)
- cpu.set_future_value_int(6, 63)
- cpu.set_future_value_int(7, 39)
- cpu.set_future_value_int(8, 78)
- cpu.set_future_value_int(9, 0)
- op = cpu.execute_token(looptoken)
+ args = [16 , 5 , 5 , 16 , 46 , 6 , 63 , 39 , 78 , 0]
+ op = cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == 105
assert cpu.get_latest_value_int(1) == 63
assert cpu.get_latest_value_int(2) == 0
@@ -154,16 +136,7 @@
operations[4].setfailargs([v2, v12, v1, v3, v4])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -5)
- cpu.set_future_value_int(1, 24)
- cpu.set_future_value_int(2, 46)
- cpu.set_future_value_int(3, -15)
- cpu.set_future_value_int(4, 13)
- cpu.set_future_value_int(5, -8)
- cpu.set_future_value_int(6, 0)
- cpu.set_future_value_int(7, -6)
- cpu.set_future_value_int(8, 6)
- cpu.set_future_value_int(9, 6)
+ args = [-5 , 24 , 46 , -15 , 13 , -8 , 0 , -6 , 6 , 6]
op = cpu.execute_token(looptoken)
assert op.identifier == 2
assert cpu.get_latest_value_int(0) == 24
@@ -205,17 +178,8 @@
operations[5].setfailargs([])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 19)
- cpu.set_future_value_int(1, -3)
- cpu.set_future_value_int(2, -58)
- cpu.set_future_value_int(3, -7)
- cpu.set_future_value_int(4, 12)
- cpu.set_future_value_int(5, 22)
- cpu.set_future_value_int(6, -54)
- cpu.set_future_value_int(7, -29)
- cpu.set_future_value_int(8, -19)
- cpu.set_future_value_int(9, -64)
- op = cpu.execute_token(looptoken)
+ args = [19 , -3 , -58 , -7 , 12 , 22 , -54 , -29 , -19 , -64]
+ op = cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == -29
assert cpu.get_latest_value_int(1) == -3
assert cpu.get_latest_value_int(2) == 22
@@ -257,17 +221,8 @@
looptoken = JitCellToken()
operations[5].setfailargs([])
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 1073741824)
- cpu.set_future_value_int(1, 95)
- cpu.set_future_value_int(2, -16)
- cpu.set_future_value_int(3, 5)
- cpu.set_future_value_int(4, 92)
- cpu.set_future_value_int(5, 12)
- cpu.set_future_value_int(6, 32)
- cpu.set_future_value_int(7, 17)
- cpu.set_future_value_int(8, 37)
- cpu.set_future_value_int(9, -63)
- op = cpu.execute_token(looptoken)
+ args = [1073741824 , 95 , -16 , 5 , 92 , 12 , 32 , 17 , 37 , -63]
+ op = cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == 1073741824
assert cpu.get_latest_value_int(1) == 5
assert cpu.get_latest_value_int(2) == -63
@@ -320,18 +275,9 @@
operations[1].setfailargs([v8, v6, v1])
operations[7].setfailargs([v4])
operations[9].setfailargs([v10, v13])
- cpu.set_future_value_int(0, 32)
- cpu.set_future_value_int(1, 41)
- cpu.set_future_value_int(2, -9)
- cpu.set_future_value_int(3, 12)
- cpu.set_future_value_int(4, -18)
- cpu.set_future_value_int(5, 46)
- cpu.set_future_value_int(6, 15)
- cpu.set_future_value_int(7, 17)
- cpu.set_future_value_int(8, 10)
- cpu.set_future_value_int(9, 12)
+ args = [32 , 41 , -9 , 12 , -18 , 46 , 15 , 17 , 10 , 12]
cpu.compile_loop(inputargs, operations, looptoken)
- op = cpu.execute_token(looptoken)
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 3
assert cpu.get_latest_value_int(0) == 12
assert cpu.get_latest_value_int(1) == 23
@@ -378,17 +324,8 @@
operations[8].setfailargs([v5, v9])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -8)
- cpu.set_future_value_int(1, 0)
- cpu.set_future_value_int(2, 62)
- cpu.set_future_value_int(3, 35)
- cpu.set_future_value_int(4, 16)
- cpu.set_future_value_int(5, 9)
- cpu.set_future_value_int(6, 30)
- cpu.set_future_value_int(7, 581610154)
- cpu.set_future_value_int(8, -1)
- cpu.set_future_value_int(9, 738197503)
- op = cpu.execute_token(looptoken)
+ args = [-8 , 0 , 62 , 35 , 16 , 9 , 30 , 581610154 , -1 , 738197503]
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 2
assert cpu.get_latest_value_int(0) == 16
assert cpu.get_latest_value_int(1) == -1
@@ -436,17 +373,8 @@
operations[-2].setfailargs([v9, v4, v10, v11, v14])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -39)
- cpu.set_future_value_int(1, -18)
- cpu.set_future_value_int(2, 1588243114)
- cpu.set_future_value_int(3, -9)
- cpu.set_future_value_int(4, -4)
- cpu.set_future_value_int(5, 1252698794)
- cpu.set_future_value_int(6, 0)
- cpu.set_future_value_int(7, 715827882)
- cpu.set_future_value_int(8, -15)
- cpu.set_future_value_int(9, 536870912)
- op = cpu.execute_token(looptoken)
+ args = [-39 , -18 , 1588243114 , -9 , -4 , 1252698794 , 0 , 715827882 , -15 , 536870912]
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 1
assert cpu.get_latest_value_int(0) == -15
assert cpu.get_latest_value_int(1) == -9
@@ -499,17 +427,8 @@
operations[9].setfailargs([v5, v7, v12, v14, v2, v13, v8])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 0)
- cpu.set_future_value_int(1, -2)
- cpu.set_future_value_int(2, 24)
- cpu.set_future_value_int(3, 1)
- cpu.set_future_value_int(4, -4)
- cpu.set_future_value_int(5, 13)
- cpu.set_future_value_int(6, -95)
- cpu.set_future_value_int(7, 33)
- cpu.set_future_value_int(8, 2)
- cpu.set_future_value_int(9, -44)
- op = cpu.execute_token(looptoken)
+ args = [0 , -2 , 24 , 1 , -4 , 13 , -95 , 33 , 2 , -44]
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 3
assert cpu.get_latest_value_int(0) == -4
assert cpu.get_latest_value_int(1) == -95
@@ -549,17 +468,8 @@
operations[2].setfailargs([v10, v3, v6, v11, v9, v2])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 3)
- cpu.set_future_value_int(1, -5)
- cpu.set_future_value_int(2, 1431655765)
- cpu.set_future_value_int(3, 47)
- cpu.set_future_value_int(4, 12)
- cpu.set_future_value_int(5, 1789569706)
- cpu.set_future_value_int(6, 15)
- cpu.set_future_value_int(7, 939524096)
- cpu.set_future_value_int(8, 16)
- cpu.set_future_value_int(9, -43)
- op = cpu.execute_token(looptoken)
+ args = [3 , -5 , 1431655765 , 47 , 12 , 1789569706 , 15 , 939524096 , 16 , -43]
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 1
assert cpu.get_latest_value_int(0) == -43
assert cpu.get_latest_value_int(1) == 1431655765
@@ -606,17 +516,8 @@
operations[4].setfailargs([v14])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 14)
- cpu.set_future_value_int(1, -20)
- cpu.set_future_value_int(2, 18)
- cpu.set_future_value_int(3, -2058005163)
- cpu.set_future_value_int(4, 6)
- cpu.set_future_value_int(5, 1)
- cpu.set_future_value_int(6, -16)
- cpu.set_future_value_int(7, 11)
- cpu.set_future_value_int(8, 0)
- cpu.set_future_value_int(9, 19)
- op = cpu.execute_token(looptoken)
+ args = [14 , -20 , 18 , -2058005163 , 6 , 1 , -16 , 11 , 0 , 19]
+ op = cpu.execute_token(looptoken, *args)
assert op.identifier == 1
assert cpu.get_latest_value_int(0) == -2058005163
assert cpu.get_latest_value_int(1) == 19
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
@@ -21,8 +21,7 @@
finish(i3, descr=fdescr2)
'''
bridge = self.attach_bridge(ops, loop, -2)
- self.cpu.set_future_value_int(0, 0)
- fail = self.run(loop)
+ fail = self.run(loop, 0)
assert fail.identifier == 2
assert self.getint(0) == 21
@@ -57,8 +56,7 @@
#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)
+ fail = self.run(loop, 0)
assert fail.identifier == 2
assert self.getint(0) == 21
assert self.getint(1) == 22
@@ -85,8 +83,7 @@
jump(i3, 1, 2, 3, 4, 5, 6, 7, descr=targettoken)
'''
bridge = self.attach_bridge(ops, other_loop, 1)
- self.cpu.set_future_value_int(0, 1)
- fail = self.run(other_loop)
+ fail = self.run(other_loop, 1)
assert fail.identifier == 1
def test_bridge_jumps_to_self_deeper(self):
@@ -125,10 +122,7 @@
# 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)
- self.cpu.set_future_value_int(2, 0)
- self.run(loop)
+ self.run(loop, 0, 0, 0)
assert self.getint(0) == 1
assert self.getint(1) == 20
@@ -152,10 +146,7 @@
jump(i3, 0, 1, descr=targettoken)
'''
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)
+ self.run(loop, 0, 0, 0)
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
@@ -151,19 +151,20 @@
loop = self.parse(ops)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
- for i, arg in enumerate(args):
+ args = []
+ for arg in args:
if isinstance(arg, int):
- self.cpu.set_future_value_int(i, arg)
+ args.append(arg)
elif isinstance(arg, float):
arg = longlong.getfloatstorage(arg)
- self.cpu.set_future_value_float(i, arg)
+ args.append(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)
+ args.append(llgcref)
loop._jitcelltoken = looptoken
if run:
- self.cpu.execute_token(looptoken)
+ self.cpu.execute_token(looptoken, *args)
return loop
def prepare_loop(self, ops):
@@ -202,8 +203,8 @@
loop._jitcelltoken)
return bridge
- def run(self, loop):
- return self.cpu.execute_token(loop._jitcelltoken)
+ def run(self, loop, *args):
+ return self.cpu.execute_token(loop._jitcelltoken, *args)
class TestRegallocSimple(BaseTestRegalloc):
@@ -245,8 +246,7 @@
jump(i4, i4, i4, i4, descr=targettoken)
'''
self.attach_bridge(bridge_ops, loop2, 5)
- self.cpu.set_future_value_int(0, 0)
- self.run(loop2)
+ self.run(loop2, 0)
assert self.getint(0) == 31
assert self.getint(1) == 30
assert self.getint(2) == 30
@@ -284,8 +284,7 @@
loop = self.interpret(ops, [0])
assert self.getint(0) == 1
self.attach_bridge(bridge_ops, loop, 2)
- self.cpu.set_future_value_int(0, 0)
- self.run(loop)
+ self.run(loop, 0)
assert self.getint(0) == 1
def test_inputarg_unused(self):
@@ -311,9 +310,7 @@
assert self.getint(0) == 0
assert self.getint(1) == 10
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)
+ relf.run(loop, 0, 10)
assert self.getint(0) == 0
assert self.getint(1) == 10
@@ -330,9 +327,7 @@
finish(1, 2)
'''
self.attach_bridge(bridge_ops, loop, 0)
- self.cpu.set_future_value_int(0, 0)
- self.cpu.set_future_value_int(1, 1)
- self.run(loop)
+ self.run(loop, 0, 1)
def test_spill_for_constant(self):
ops = '''
@@ -450,9 +445,8 @@
finish(i0, i1, i2, i3, i4, i5, i6, i7, i8)
'''
self.attach_bridge(bridge_ops, loop, 1)
- for i in range(9):
- self.cpu.set_future_value_int(i, i)
- self.run(loop)
+ args = [i for i in range(9)]
+ self.run(loop, *args)
assert self.getints(9) == range(9)
def test_loopargs(self):
@@ -725,9 +719,7 @@
'''
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)
+ self.run(loop, 4, 7)
assert self.getint(0) == 5 * 7
def test_bridge_calls_2(self):
@@ -746,9 +738,7 @@
'''
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)
+ self.run(loop, 4, 7)
assert self.getint(0) == 29
@@ -787,7 +777,7 @@
large = self.interpret(loop1, range(11), run=False)
large._jitcelltoken.outermost_jitdriver_sd = FakeJitDriverSD()
self.namespace['looptoken'] = large._jitcelltoken
- assert self.namespace['looptoken']._arm_bootstrap_code != 0
+ assert self.namespace['looptoken']._arm_func_addr != 0
loop2 = """
[i0]
i1 = force_token()
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
@@ -25,8 +25,7 @@
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 9)
- cpu.execute_token(looptoken)
+ cpu.execute_token(looptoken, 9)
assert cpu.get_latest_value_int(0) == (9 >> 3)
assert cpu.get_latest_value_int(1) == (~18)
@@ -48,8 +47,7 @@
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -10)
- cpu.execute_token(looptoken)
+ cpu.execute_token(looptoken, -10)
assert cpu.get_latest_value_int(0) == 0
assert cpu.get_latest_value_int(1) == -1000
assert cpu.get_latest_value_int(2) == 1
@@ -145,17 +143,8 @@
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, -13)
- cpu.set_future_value_int(1, 10)
- cpu.set_future_value_int(2, 10)
- cpu.set_future_value_int(3, 8)
- cpu.set_future_value_int(4, -8)
- cpu.set_future_value_int(5, -16)
- cpu.set_future_value_int(6, -18)
- cpu.set_future_value_int(7, 46)
- cpu.set_future_value_int(8, -12)
- cpu.set_future_value_int(9, 26)
- cpu.execute_token(looptoken)
+ args = [-13 , 10 , 10 , 8 , -8 , -16 , -18 , 46 , -12 , 26]
+ cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == 0
assert cpu.get_latest_value_int(1) == 0
assert cpu.get_latest_value_int(2) == 0
@@ -260,17 +249,8 @@
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
- cpu.set_future_value_int(0, 17)
- cpu.set_future_value_int(1, -20)
- cpu.set_future_value_int(2, -6)
- cpu.set_future_value_int(3, 6)
- cpu.set_future_value_int(4, 1)
- cpu.set_future_value_int(5, 13)
- cpu.set_future_value_int(6, 13)
- cpu.set_future_value_int(7, 9)
- cpu.set_future_value_int(8, 49)
- cpu.set_future_value_int(9, 8)
- cpu.execute_token(looptoken)
+ args = [17 , -20 , -6 , 6 , 1 , 13 , 13 , 9 , 49 , 8]
+ cpu.execute_token(looptoken, *args)
assert cpu.get_latest_value_int(0) == 0
assert cpu.get_latest_value_int(1) == 8
assert cpu.get_latest_value_int(2) == 1
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
@@ -57,9 +57,8 @@
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)
- self.cpu.execute_token(looptoken)
+ args = [i for i in range(1, 15)]
+ self.cpu.execute_token(looptoken, *args)
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
@@ -100,26 +99,13 @@
self.cpu.compile_loop(loop2.inputargs, loop2.operations, lt2)
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)
- self.cpu.execute_token(lt1)
+ self.cpu.execute_token(lt1, 11)
assert self.cpu.get_latest_value_int(0) == 12
self.cpu.redirect_call_assembler(lt2, lt3)
- self.cpu.set_future_value_int(0, 11)
- self.cpu.execute_token(lt1)
+ self.cpu.execute_token(lt1, 11)
assert self.cpu.get_latest_value_int(0) == 10
- def test_new_array_with_const_length(self):
- """ Test for an issue with malloc_varsize when the size is an imm
- that gets lost around the call to malloc"""
- A = lltype.GcArray(lltype.Signed)
- arraydescr = self.cpu.arraydescrof(A)
- r1 = self.execute_operation(rop.NEW_ARRAY, [ConstInt(6)],
- 'ref', descr=arraydescr)
- a = lltype.cast_opaque_ptr(lltype.Ptr(A), r1.value)
- assert a[0] == 0
- assert len(a) == 6
-
def test_cond_call_gc_wb_array_card_marking_fast_path(self):
py.test.skip('ignore this fast path for now')
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
@@ -47,12 +47,11 @@
ResOperation(rop.JUMP, [i1b], None, descr=looptoken),
]
bridge[1].setfailargs([i1b])
- assert looptoken._arm_bootstrap_code != 0
+ assert looptoken._arm_func_addr != 0
assert looptoken._arm_loop_code != 0
cpu.compile_bridge(faildescr1, [i1b], bridge, looptoken, True)
- cpu.set_future_value_int(0, 2)
- fail = cpu.execute_token(looptoken)
+ fail = cpu.execute_token(looptoken, 2)
res = cpu.get_latest_value_int(0)
return fail.identifier * 1000 + res
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
@@ -1225,7 +1225,7 @@
loop = parse(loopops)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
- args = [1]
+ args = [1]
args.append(longlong.getfloatstorage(132.25))
args.append(longlong.getfloatstorage(0.75))
fail = self.cpu.execute_token(looptoken, *args) #xxx check
@@ -1242,10 +1242,10 @@
]
self.cpu.compile_bridge(loop.operations[-2].getdescr(), fboxes,
bridgeops, looptoken)
- self.cpu.set_future_value_int(0, 1)
- self.cpu.set_future_value_float(1, longlong.getfloatstorage(132.25))
- self.cpu.set_future_value_float(2, longlong.getfloatstorage(0.75))
- fail = self.cpu.execute_token(looptoken)
+ args = [1,
+ longlong.getfloatstorage(132.25),
+ longlong.getfloatstorage(0.75)]
+ fail = self.cpu.execute_token(looptoken, *args)
assert fail.identifier == 100
f1 = self.cpu.get_latest_value_float(0)
f2 = self.cpu.get_latest_value_float(1)
@@ -1278,8 +1278,7 @@
#
cpu = self.cpu
for value in [-42, 0, 1, 10]:
- cpu.set_future_value_int(0, value)
- fail = cpu.execute_token(looptoken)
+ fail = cpu.execute_token(looptoken, value)
#
expected = compare(value)
expected ^= guard_case
diff --git a/pypy/jit/backend/test/test_frame_size.py b/pypy/jit/backend/test/test_frame_size.py
--- a/pypy/jit/backend/test/test_frame_size.py
+++ b/pypy/jit/backend/test/test_frame_size.py
@@ -85,7 +85,7 @@
"""
large = self.interpret(large_frame_loop, range(15), run=False)
self.namespace['looptoken'] = large.token
- assert self.namespace['looptoken']._arm_bootstrap_code != 0
+ assert self.namespace['looptoken']._arm_func_addr != 0
small_frame_loop = """
[i0]
i1 = int_add(i0, 1)
More information about the pypy-commit
mailing list