[pypy-svn] r67878 - in pypy/branch/remove-plfbid/pypy/jit: backend/test backend/x86 backend/x86/test metainterp
pedronis at codespeak.net
pedronis at codespeak.net
Fri Sep 25 15:07:45 CEST 2009
Author: pedronis
Date: Fri Sep 25 15:07:44 2009
New Revision: 67878
Modified:
pypy/branch/remove-plfbid/pypy/jit/backend/test/runner_test.py
pypy/branch/remove-plfbid/pypy/jit/backend/x86/assembler.py
pypy/branch/remove-plfbid/pypy/jit/backend/x86/regalloc.py
pypy/branch/remove-plfbid/pypy/jit/backend/x86/runner.py
pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_regalloc2.py
pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_runner.py
pypy/branch/remove-plfbid/pypy/jit/metainterp/compile.py
pypy/branch/remove-plfbid/pypy/jit/metainterp/history.py
Log:
(arigo, pedronis) "final" cleanups
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/test/runner_test.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/test/runner_test.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/test/runner_test.py Fri Sep 25 15:07:44 2009
@@ -198,7 +198,10 @@
def test_finish(self):
i0 = BoxInt()
- faildescr = AbstractFailDescr() # to check that is not touched
+ class UntouchableFailDescr(AbstractFailDescr):
+ def __setattr__(self, name, value):
+ py.test.fail("finish descrs should not be touched")
+ faildescr = UntouchableFailDescr() # to check that is not touched
operations = [
ResOperation(rop.FINISH, [i0], None, descr=faildescr)
]
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/x86/assembler.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/x86/assembler.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/x86/assembler.py Fri Sep 25 15:07:44 2009
@@ -2,6 +2,7 @@
import ctypes
from pypy.jit.backend.llsupport import symbolic
from pypy.jit.metainterp.history import Const, Box, BoxPtr, REF
+from pypy.jit.metainterp.history import AbstractFailDescr
from pypy.rpython.lltypesystem import lltype, rffi, ll2ctypes, rstr, llmemory
from pypy.rpython.lltypesystem.rclass import OBJECT
from pypy.rpython.lltypesystem.lloperation import llop
@@ -64,9 +65,10 @@
setattr(MachineCodeBlockWrapper, name, _new_method(name))
class ExecutableToken386(object):
- _x86_compiled = 0
+ _x86_loop_code = 0
_x86_bootstrap_code = 0
_x86_stack_depth = 0
+ _x86_arglocs = None
class Assembler386(object):
mc = None
@@ -125,47 +127,45 @@
self.mc = MachineCodeBlockWrapper()
self.mc2 = MachineCodeBlockWrapper()
- def _compute_longest_fail_op(self, ops):
- max_so_far = 0
- for op in ops:
- if op.opnum == rop.FAIL:
- max_so_far = max(max_so_far, len(op.args))
- if op.is_guard():
- max_so_far = max(max_so_far, self._compute_longest_fail_op(
- op.suboperations))
- assert max_so_far < MAX_FAIL_BOXES
- return max_so_far
-
def assemble_loop(self, inputargs, operations):
- self._compute_longest_fail_op(operations)
self.make_sure_mc_exists()
regalloc = RegAlloc(self, self.cpu.translate_support_code)
- self._regalloc = regalloc
- regalloc.walk_operations(inputargs, operations)
- self.mc.done()
- self.mc2.done()
- if we_are_translated() or self.cpu.dont_keepalive_stuff:
- self._regalloc = None # else keep it around for debugging
- stack_depth = regalloc.current_stack_depth
- jump_target = regalloc.jump_target
- if jump_target is not None:
- target_stack_depth = jump_target.executable_token._x86_stack_depth
- stack_depth = max(stack_depth, target_stack_depth)
- executable_token = regalloc.executable_token
- # possibly align, e.g. for Mac OS X
+ arglocs = regalloc.prepare_loop(inputargs, operations)
+ executable_token = ExecutableToken386()
+ executable_token._x86_arglocs = arglocs
+ executable_token._x86_bootstrap_code = self.mc.tell()
+ adr_stackadjust = self._assemble_bootstrap_code(inputargs, arglocs)
+ executable_token._x86_loop_code = self.mc.tell()
+ self._executable_token = executable_token
+ stack_depth = self._assemble(regalloc, operations)
+ self._executable_token = None
+ self._patch_stackadjust(adr_stackadjust, stack_depth)
executable_token._x86_stack_depth = stack_depth
return executable_token
def assemble_bridge(self, faildescr, inputargs, operations):
- self._compute_longest_fail_op(operations)
self.make_sure_mc_exists()
regalloc = RegAlloc(self, self.cpu.translate_support_code)
+ arglocs = faildescr._x86_faillocs
+ fail_stack_depth = faildescr._x86_current_stack_depth
+ regalloc.prepare_bridge(fail_stack_depth, inputargs, arglocs,
+ operations)
+ adr_bridge = self.mc.tell()
+ adr_stackadjust = self._patchable_stackadjust()
+ stack_depth = self._assemble(regalloc, operations)
+ self._patch_stackadjust(adr_stackadjust, stack_depth)
+ if not we_are_translated():
+ # for the benefit of tests
+ faildescr._x86_bridge_stack_depth = stack_depth
+ # patch the jump from original guard
+ adr_jump_offset = faildescr._x86_adr_jump_offset
+ mc = codebuf.InMemoryCodeBuilder(adr_jump_offset, adr_jump_offset + 4)
+ mc.write(packimm32(adr_bridge - adr_jump_offset - 4))
+ mc.done()
+
+ def _assemble(self, regalloc, operations):
self._regalloc = regalloc
- # stack adjustment LEA
- mc = self.mc._mc
- adr_bridge = mc.tell()
- mc.LEA(esp, fixedsize_ebp_ofs(0))
- regalloc.walk_bridge(faildescr, inputargs, operations)
+ regalloc.walk_operations(operations)
self.mc.done()
self.mc2.done()
if we_are_translated() or self.cpu.dont_keepalive_stuff:
@@ -175,60 +175,21 @@
if jump_target is not None:
target_stack_depth = jump_target.executable_token._x86_stack_depth
stack_depth = max(stack_depth, target_stack_depth)
+ return stack_depth
+
+ def _patchable_stackadjust(self):
+ # stack adjustment LEA
+ self.mc.LEA(esp, fixedsize_ebp_ofs(0))
+ return self.mc.tell() - 4
+
+ def _patch_stackadjust(self, adr_lea, stack_depth):
# patch stack adjustment LEA
- if not we_are_translated():
- # for the benefit of tests
- faildescr._x86_bridge_stack_depth = stack_depth
- mc = codebuf.InMemoryCodeBuilder(adr_bridge, adr_bridge + 128)
- mc.LEA(esp, fixedsize_ebp_ofs(-(stack_depth + RET_BP - 2) * WORD))
- mc.done()
- # patch the jump from original guard
- addr = faildescr._x86_addr
- mc = codebuf.InMemoryCodeBuilder(addr, addr + 128)
- mc.write(packimm32(adr_bridge - addr - 4))
+ # possibly align, e.g. for Mac OS X
+ mc = codebuf.InMemoryCodeBuilder(adr_lea, adr_lea + 4)
+ mc.write(packimm32(-(stack_depth + RET_BP - 2) * WORD))
mc.done()
-## def assemble(self, tree, operations, guard_op):
-## # the last operation can be 'jump', 'return' or 'guard_pause';
-## # a 'jump' can either close a loop, or end a bridge to some
-## # previously-compiled code.
-## self._compute_longest_fail_op(operations)
-## self.make_sure_mc_exists()
-## newpos = self.mc.tell()
-## regalloc = RegAlloc(self, tree, self.cpu.translate_support_code,
-## guard_op)
-## self._regalloc = regalloc
-## adr_lea = 0
-## if guard_op is None:
-## inputargs = tree.inputargs
-## regalloc.walk_operations(tree)
-## else:
-## inputargs = regalloc.inputargs
-## mc = self.mc._mc
-## adr_lea = mc.tell()
-## mc.LEA(esp, fixedsize_ebp_ofs(0))
-## regalloc._walk_operations(operations)
-## stack_depth = regalloc.max_stack_depth
-## self.mc.done()
-## self.mc2.done()
-## # possibly align, e.g. for Mac OS X
-## if guard_op is None:
-## tree._x86_stack_depth = stack_depth
-## else:
-## if not we_are_translated():
-## # for the benefit of tests
-## guard_op._x86_bridge_stack_depth = stack_depth
-## mc = codebuf.InMemoryCodeBuilder(adr_lea, adr_lea + 128)
-
-## mc.LEA(esp, fixedsize_ebp_ofs(-(stack_depth + RET_BP - 2) * WORD))
-## mc.done()
-## if we_are_translated():
-## self._regalloc = None # else keep it around for debugging
-## return newpos
-
- def assemble_bootstrap_code(self, jumpaddr, arglocs, argtypes, framesize):
- self.make_sure_mc_exists()
- addr = self.mc.tell()
+ def _assemble_bootstrap_code(self, inputargs, arglocs):
self.mc.PUSH(ebp)
self.mc.MOV(ebp, esp)
self.mc.PUSH(ebx)
@@ -236,11 +197,11 @@
self.mc.PUSH(edi)
# NB. exactly 4 pushes above; if this changes, fix stack_pos().
# You must also keep _get_callshape() in sync.
- self.mc.SUB(esp, imm(framesize * WORD))
+ adr_stackadjust = self._patchable_stackadjust()
for i in range(len(arglocs)):
loc = arglocs[i]
if not isinstance(loc, REG):
- if argtypes[i] == REF:
+ if inputargs[i].type == REF:
# This uses XCHG to put zeroes in fail_boxes_ptr after
# reading them
self.mc.XOR(ecx, ecx)
@@ -253,7 +214,7 @@
for i in range(len(arglocs)):
loc = arglocs[i]
if isinstance(loc, REG):
- if argtypes[i] == REF:
+ if inputargs[i].type == REF:
# This uses XCHG to put zeroes in fail_boxes_ptr after
# reading them
self.mc.XOR(loc, loc)
@@ -262,9 +223,7 @@
else:
self.mc.MOV(loc, addr_add(imm(self.fail_box_int_addr),
imm(i*WORD)))
- self.mc.JMP(rel32(jumpaddr))
- self.mc.done()
- return addr
+ return adr_stackadjust
def dump(self, text):
if not self.verbose:
@@ -299,6 +258,7 @@
arglocs, resloc, current_stack_depth):
fail_op = guard_op.suboperations[0]
faildescr = fail_op.descr
+ assert isinstance(faildescr, AbstractFailDescr)
faildescr._x86_current_stack_depth = current_stack_depth
failargs = fail_op.args
guard_opnum = guard_op.opnum
@@ -309,10 +269,11 @@
dispatch_opnum = guard_opnum
else:
dispatch_opnum = op.opnum
- addr = genop_guard_list[dispatch_opnum](self, op, guard_opnum,
- failaddr, arglocs,
- resloc)
- faildescr._x86_addr = addr
+ adr_jump_offset = genop_guard_list[dispatch_opnum](self, op,
+ guard_opnum,
+ failaddr, arglocs,
+ resloc)
+ faildescr._x86_adr_jump_offset = adr_jump_offset
def regalloc_perform_guard(self, guard_op, faillocs, arglocs, resloc,
current_stack_depth):
@@ -628,32 +589,6 @@
else:
assert 0, itemsize
- def make_merge_point(self, argtypes, locs):
- executable_token = ExecutableToken386()
- pos = self.mc.tell()
- executable_token.argtypes = argtypes
- executable_token.arglocs = locs
- executable_token._x86_compiled = pos
- return executable_token
-
- def _get_executable_token(self, loop_token, cur_executable_token):
- if loop_token is not None:
- return loop_token.executable_token
- return cur_executable_token
-
- def extract_merge_point(self, loop_token, cur_executable_token):
- executable_token = self._get_executable_token(loop_token,
- cur_executable_token)
- return executable_token.arglocs
-
- def closing_jump(self, loop_token, cur_executable_token):
- executable_token = self._get_executable_token(loop_token,
- cur_executable_token)
- self.mc.JMP(rel32(executable_token._x86_compiled))
-
- #def genop_discard_jump(self, op, locs):
- # self.mc.JMP(rel32(op.jump_target._x86_compiled))
-
def genop_guard_guard_true(self, ign_1, guard_opnum, addr, locs, ign_2):
loc = locs[0]
self.mc.TEST(loc, loc)
@@ -709,6 +644,7 @@
return addr
def generate_failure(self, mc, faildescr, failargs, locs, exc):
+ assert len(failargs) < MAX_FAIL_BOXES
pos = mc.tell()
for i in range(len(locs)):
loc = locs[i]
@@ -744,8 +680,9 @@
# don't break the following code sequence!
mc = mc._mc
mc.LEA(esp, addr_add(imm(0), ebp, (-RET_BP + 2) * WORD))
- guard_index = self.cpu.make_guard_index(faildescr)
- mc.MOV(eax, imm(guard_index))
+ assert isinstance(faildescr, AbstractFailDescr)
+ fail_index = self.cpu.make_fail_index(faildescr)
+ mc.MOV(eax, imm(fail_index))
mc.POP(edi)
mc.POP(esi)
mc.POP(ebx)
@@ -826,6 +763,20 @@
mark = self._regalloc.get_mark_gc_roots(gcrootmap)
gcrootmap.put(rffi.cast(llmemory.Address, self.mc.tell()), mark)
+ def _get_executable_token(self, loop_token):
+ if loop_token is not None:
+ return loop_token.executable_token
+ assert self._executable_token is not None
+ return self._executable_token
+
+ def target_arglocs(self, loop_token):
+ executable_token = self._get_executable_token(loop_token)
+ return executable_token._x86_arglocs
+
+ def closing_jump(self, loop_token):
+ executable_token = self._get_executable_token(loop_token)
+ self.mc.JMP(rel32(executable_token._x86_loop_code))
+
genop_discard_list = [Assembler386.not_implemented_op_discard] * rop._LAST
genop_list = [Assembler386.not_implemented_op] * rop._LAST
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/x86/regalloc.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/x86/regalloc.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/x86/regalloc.py Fri Sep 25 15:07:44 2009
@@ -66,11 +66,10 @@
self.longevity = None
# to be read/used by the assembler too
- self.executable_token = None
self.current_stack_depth = 0
self.jump_target = None
- def walk_operations(self, inputargs, operations):
+ def prepare_loop(self, inputargs, operations):
cpu = self.assembler.cpu
cpu.gc_ll_descr.rewrite_assembler(cpu, operations)
# compute longevity of variables
@@ -80,48 +79,16 @@
self.loop_consts = loop_consts
self.current_stack_depth = 0
self.free_regs = REGS[:]
- self.executable_token = self._process_inputargs(inputargs)
- self._walk_operations(operations)
+ return self._process_inputargs(inputargs)
- def walk_bridge(self, faildescr, inputargs, operations):
+ def prepare_bridge(self, prev_stack_depth, inputargs, arglocs, operations):
cpu = self.assembler.cpu
- locs = faildescr._x86_faillocs
cpu.gc_ll_descr.rewrite_assembler(cpu, operations)
# compute longevity of variables
self._compute_vars_longevity(inputargs, operations)
self.loop_consts = {}
- self._update_bindings(locs, inputargs)
- self.current_stack_depth = faildescr._x86_current_stack_depth
- self._walk_operations(operations)
-
-## def x__init__(self, assembler, tree, translate_support_code=False,
-## guard_op=None):
-## # variables that have place in register
-## self.assembler = assembler
-## self.translate_support_code = translate_support_code
-## cpu = self.assembler.cpu
-## self.reg_bindings = newcheckdict()
-## self.stack_bindings = newcheckdict()
-## self.tree = tree
-## if guard_op is not None:
-## locs = guard_op._x86_faillocs
-## cpu.gc_ll_descr.rewrite_assembler(cpu, guard_op.suboperations)
-## inpargs = [arg for arg in guard_op._fail_op.args if
-## isinstance(arg, Box)]
-## self._compute_vars_longevity(inpargs, guard_op.suboperations)
-## self.position = -1
-## self._update_bindings(locs, inpargs)
-## self.current_stack_depth = guard_op._x86_current_stack_depth
-## self.loop_consts = {}
-## else:
-## cpu.gc_ll_descr.rewrite_assembler(cpu, tree.operations)
-## self._compute_vars_longevity(tree.inputargs, tree.operations)
-## # compute longevity of variables
-## jump = tree.operations[-1]
-## loop_consts = self._compute_loop_consts(tree.inputargs, jump)
-## self.loop_consts = loop_consts
-## self.current_stack_depth = 0
-## self.free_regs = REGS[:]
+ self._update_bindings(arglocs, inputargs)
+ self.current_stack_depth = prev_stack_depth
def _process_inputargs(self, inputargs):
# XXX we can sort out here by longevity if we need something
@@ -131,10 +98,8 @@
# Must be kept in sync with consider_jump().
tmpreg = self.free_regs.pop(0)
assert tmpreg == REGS[0]
- argtypes = []
for i in range(len(inputargs)):
arg = inputargs[i]
- argtypes.append(arg.type)
assert not isinstance(arg, Const)
reg = None
if arg not in self.loop_consts and self.longevity[arg][1] > -1:
@@ -147,10 +112,8 @@
# otherwise we have it saved on stack, so no worry
self.free_regs.insert(0, tmpreg)
assert tmpreg not in locs
- # xxx think
- executable_token = self.assembler.make_merge_point(argtypes, locs)
self.eventually_free_vars(inputargs)
- return executable_token
+ return locs
def _compute_loop_consts(self, inputargs, jump):
if jump.opnum != rop.JUMP or jump.jump_target is not None:
@@ -265,22 +228,7 @@
return False
return True
-## def walk_operations(self, tree):
-## # first pass - walk along the operations in order to find
-## # load/store places
-## self.position = -1
-## operations = tree.operations
-## self.process_inputargs(tree)
-## self._walk_operations(operations)
-
- #def walk_guard_ops(self, inputargs, operations, exc):
- # self.exc = exc
- # old_regalloc = self.assembler._regalloc
- # self.assembler._regalloc = self
- # self._walk_operations(operations)
- # self.assembler._regalloc = old_regalloc
-
- def _walk_operations(self, operations):
+ def walk_operations(self, operations):
i = 0
#self.operations = operations
while i < len(operations):
@@ -331,33 +279,6 @@
assert isinstance(arg, Box)
self.longevity = longevity
-# def _compute_inpargs(self, guard):
-# operations = guard.suboperations
-# longevity = {}
-# end = {}
-# for i in range(len(operations)-1, -1, -1):
-# op = operations[i]
-# if op.is_guard():
-# for arg in op.suboperations[0].args:
-# if isinstance(arg, Box) and arg not in end:
-# end[arg] = i
-# for arg in op.args:
-# if isinstance(arg, Box) and arg not in end:
-# end[arg] = i
-# if op.result:
-# if op.result in end:
-# longevity[op.result] = (i, end[op.result])
-# del end[op.result]
-# # otherwise this var is never ever used
-# for v, e in end.items():
-# longevity[v] = (0, e)
-# inputargs = end.keys()
-# for arg in longevity:
-# assert isinstance(arg, Box)
-# for arg in inputargs:
-# assert isinstance(arg, Box)
-# return inputargs, longevity
-
def try_allocate_reg(self, v, selected_reg=None, need_lower_byte=False):
assert not isinstance(v, Const)
if selected_reg is not None:
@@ -961,8 +882,7 @@
assembler = self.assembler
assert self.jump_target is None
self.jump_target = op.jump_target
- arglocs = assembler.extract_merge_point(self.jump_target,
- self.executable_token)
+ arglocs = assembler.target_arglocs(self.jump_target)
# compute 'tmploc' to be REGS[0] by spilling what is there
box = TempBox()
tmploc = self.force_allocate_reg(box, [], selected_reg=REGS[0])
@@ -972,7 +892,7 @@
remap_stack_layout(assembler, src_locations, dst_locations, tmploc)
self.eventually_free_var(box)
self.eventually_free_vars(op.args)
- assembler.closing_jump(op.jump_target, self.executable_token)
+ assembler.closing_jump(self.jump_target)
def consider_debug_merge_point(self, op, ignored):
pass
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/x86/runner.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/x86/runner.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/x86/runner.py Fri Sep 25 15:07:44 2009
@@ -20,7 +20,7 @@
AbstractLLCPU.__init__(self, rtyper, stats, translate_support_code,
gcdescr)
self._bootstrap_cache = {}
- self._guard_list = []
+ self._faildescr_list = []
if rtyper is not None: # for tests
self.lltype2vtable = rtyper.lltype_to_vtable_mapping()
@@ -39,24 +39,10 @@
def compile_bridge(self, faildescr, inputargs, operations):
self.assembler.assemble_bridge(faildescr, inputargs, operations)
- def execute_token(self, executable_token):
- func = self.get_bootstrap_code(executable_token)
- guard_index = self.execute_call(func)
- op = self._guard_list[guard_index] # xxx
- return op
-
- def get_bootstrap_code(self, executable_token):
- addr = executable_token._x86_bootstrap_code
- if not addr:
- arglocs = executable_token.arglocs
- addr = self.assembler.assemble_bootstrap_code(
- executable_token._x86_compiled,
- arglocs,
- executable_token.argtypes,
- executable_token._x86_stack_depth)
- executable_token._x86_bootstrap_code = addr
- func = rffi.cast(lltype.Ptr(self.BOOTSTRAP_TP), addr)
- return func
+ def make_fail_index(self, faildescr):
+ index = len(self._faildescr_list)
+ self._faildescr_list.append(faildescr)
+ return index
def set_future_value_int(self, index, intvalue):
assert index < MAX_FAIL_BOXES, "overflow!"
@@ -76,7 +62,14 @@
llmemory.GCREF.TO)
return ptrvalue
- def execute_call(self, func):
+ def execute_token(self, executable_token):
+ addr = executable_token._x86_bootstrap_code
+ func = rffi.cast(lltype.Ptr(self.BOOTSTRAP_TP), addr)
+ faildescr_index = self._execute_call(func)
+ faildescr = self._faildescr_list[faildescr_index]
+ return faildescr
+
+ def _execute_call(self, func):
# help flow objspace
prev_interpreter = None
if not self.translate_support_code:
@@ -93,11 +86,6 @@
LLInterpreter.current_interpreter = prev_interpreter
return res
- def make_guard_index(self, guard_op):
- index = len(self._guard_list)
- self._guard_list.append(guard_op)
- return index
-
@staticmethod
def cast_ptr_to_int(x):
adr = llmemory.cast_ptr_to_adr(x)
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_regalloc2.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_regalloc2.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_regalloc2.py Fri Sep 25 15:07:44 2009
@@ -1,6 +1,6 @@
import py
from pypy.jit.metainterp.history import ResOperation, BoxInt, ConstInt,\
- BoxPtr, ConstPtr
+ BoxPtr, ConstPtr, BasicFailDescr
from pypy.jit.metainterp.resoperation import rop
from pypy.jit.backend.x86.runner import CPU
@@ -14,7 +14,7 @@
ResOperation(rop.INT_ADD, [v1, v1], v2),
ResOperation(rop.INT_INVERT, [v2], v3),
ResOperation(rop.UINT_RSHIFT, [v1, ConstInt(3)], v4),
- ResOperation(rop.FAIL, [v4, v3], None),
+ ResOperation(rop.FAIL, [v4, v3], None, descr=BasicFailDescr()),
]
cpu = CPU(None, None)
executable_token = cpu.compile_loop(inputargs, operations)
@@ -35,7 +35,7 @@
ResOperation(rop.INT_MUL, [v2, v1], v3),
ResOperation(rop.INT_IS_TRUE, [v2], tmp5),
ResOperation(rop.BOOL_NOT, [tmp5], v4),
- ResOperation(rop.FAIL, [v4, v3, tmp5], None),
+ ResOperation(rop.FAIL, [v4, v3, tmp5], None, descr=BasicFailDescr()),
]
cpu = CPU(None, None)
executable_token = cpu.compile_loop(inputargs, operations)
@@ -130,7 +130,7 @@
ResOperation(rop.UINT_GT, [v33, ConstInt(-11)], v38),
ResOperation(rop.INT_NEG, [v7], v39),
ResOperation(rop.INT_GT, [v24, v32], v40),
- ResOperation(rop.FAIL, [v40, v36, v37, v31, v16, v34, v35, v23, v22, v29, v14, v39, v30, v38], None),
+ ResOperation(rop.FAIL, [v40, v36, v37, v31, v16, v34, v35, v23, v22, v29, v14, v39, v30, v38], None, descr=BasicFailDescr()),
]
cpu = CPU(None, None)
executable_token = cpu.compile_loop(inputargs, operations)
@@ -243,7 +243,7 @@
ResOperation(rop.INT_GT, [v4, v11], v38),
ResOperation(rop.INT_LT, [v27, v22], v39),
ResOperation(rop.INT_NEG, [v27], v40),
- ResOperation(rop.FAIL, [v40, v10, v36, v26, v13, v30, v21, v33, v18, v25, v31, v32, v28, v29, v35, v38, v20, v39, v34, v23, v37], None),
+ ResOperation(rop.FAIL, [v40, v10, v36, v26, v13, v30, v21, v33, v18, v25, v31, v32, v28, v29, v35, v38, v20, v39, v34, v23, v37], None, descr=BasicFailDescr()),
]
cpu = CPU(None, None)
executable_token = cpu.compile_loop(inputargs, operations)
Modified: pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_runner.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_runner.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/backend/x86/test/test_runner.py Fri Sep 25 15:07:44 2009
@@ -320,7 +320,8 @@
ops = [
ResOperation(op, [b], f),
ResOperation(guard, [f], None),
- ResOperation(rop.FAIL, [ConstInt(0)], None),
+ ResOperation(rop.FAIL, [ConstInt(0)], None,
+ descr=BasicFailDescr()),
]
ops[1].suboperations = [ResOperation(rop.FAIL,
[ConstInt(1)], None,
@@ -364,7 +365,8 @@
ops = [
ResOperation(op, [a, b], res),
ResOperation(guard, [res], None),
- ResOperation(rop.FAIL, [ConstInt(0)], None),
+ ResOperation(rop.FAIL, [ConstInt(0)], None,
+ descr=BasicFailDescr()),
]
ops[1].suboperations = [ResOperation(rop.FAIL,
[ConstInt(1)], None,
Modified: pypy/branch/remove-plfbid/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/metainterp/compile.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/metainterp/compile.py Fri Sep 25 15:07:44 2009
@@ -40,7 +40,6 @@
to the first operation.
"""
from pypy.jit.metainterp.pyjitpl import DEBUG
-
history = metainterp.history
loop = create_empty_loop(metainterp)
loop.greenkey = greenkey
Modified: pypy/branch/remove-plfbid/pypy/jit/metainterp/history.py
==============================================================================
--- pypy/branch/remove-plfbid/pypy/jit/metainterp/history.py (original)
+++ pypy/branch/remove-plfbid/pypy/jit/metainterp/history.py Fri Sep 25 15:07:44 2009
@@ -119,15 +119,15 @@
class AbstractDescr(AbstractValue):
__slots__ = ()
- def handle_fail_op(self, metainterp, fail_op):
- raise NotImplementedError
- def compile_and_attach(self, metainterp, new_loop):
- raise NotImplementedError
def repr_of_descr(self):
return '%r' % (self,)
class AbstractFailDescr(AbstractDescr):
- __slots__ = ()
+
+ def handle_fail(self, metainterp_sd):
+ raise NotImplementedError
+ def compile_and_attach(self, metainterp, new_loop):
+ raise NotImplementedError
class BasicFailDescr(AbstractFailDescr):
pass
More information about the Pypy-commit
mailing list