[pypy-commit] pypy result-in-resops: (arigo, fijal) fix fix fix
fijal
noreply at buildbot.pypy.org
Mon Oct 22 17:52:05 CEST 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: result-in-resops
Changeset: r58365:4c8286636abf
Date: 2012-10-22 17:51 +0200
http://bitbucket.org/pypy/pypy/changeset/4c8286636abf/
Log: (arigo, fijal) fix fix fix
diff --git a/pypy/jit/backend/llgraph/runner.py b/pypy/jit/backend/llgraph/runner.py
--- a/pypy/jit/backend/llgraph/runner.py
+++ b/pypy/jit/backend/llgraph/runner.py
@@ -654,9 +654,6 @@
while True:
assert not self.lltrace.has_been_freed
op = self.lltrace.operations[i]
- if op.getopnum() == -124: # force_spill, for tests
- i += 1
- continue
args = [self.lookup(arg) for arg in op.getarglist()]
self.current_op = op # for label
self.current_index = i
@@ -718,6 +715,9 @@
def fail_guard(self, descr):
raise GuardFailed(self._getfailargs(), descr)
+ def execute_force_spill(self, _, arg):
+ pass
+
def execute_finish(self, descr, arg=None):
if self.current_op.getfailargs() is not None:
failargs = self._getfailargs()
@@ -855,6 +855,10 @@
self.last_exception = lle
res = _example_res[getkind(TP.RESULT)[0]]
return res
+ execute_call_i = execute_call
+ execute_call_r = execute_call
+ execute_call_f = execute_call
+ execute_call_v = execute_call
def execute_call_may_force(self, calldescr, func, *args):
call_op = self.lltrace.operations[self.current_index]
@@ -866,6 +870,10 @@
del self.latest_descr
del self.latest_values
return res
+ execute_call_may_force_i = execute_call_may_force
+ execute_call_may_force_r = execute_call_may_force
+ execute_call_may_force_f = execute_call_may_force
+ execute_call_may_force_v = execute_call_may_force
def execute_call_release_gil(self, descr, func, *args):
call_args = support.cast_call_args_in_order(descr.ARGS, args)
@@ -900,8 +908,10 @@
del self.latest_values
return support.cast_result(lltype.typeOf(result), result)
- def execute_same_as(self, _, x):
+ def execute_same_as_i(self, _, x):
return x
+ execute_same_as_f = execute_same_as_i
+ execute_same_as_r = execute_same_as_i
def execute_debug_merge_point(self, descr, *args):
from pypy.jit.metainterp.warmspot import get_stats
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
@@ -5,7 +5,7 @@
JitCellToken, TargetToken)
from pypy.jit.metainterp.resoperation import rop, create_resop_dispatch,\
create_resop, ConstInt, ConstPtr, ConstFloat, create_resop_2,\
- create_resop_1, create_resop_0, INT, REF, FLOAT
+ create_resop_1, create_resop_0, INT, REF, FLOAT, example_for_opnum
from pypy.jit.metainterp.typesystem import deref
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.rpython.lltypesystem import lltype, llmemory, rstr, rffi, rclass
@@ -18,7 +18,9 @@
from pypy.jit.tool.oparser import parse
-def boxfloat(x):
+def boxfloat(x=None):
+ if x is None:
+ x = example_for_opnum(rop.INPUT_f)
return create_resop_0(rop.INPUT_f, longlong.getfloatstorage(x))
def boxint(x=0):
@@ -88,19 +90,21 @@
result = 0.0
else:
raise ValueError(result_type)
- op0 = create_resop_dispatch(opnum, result, valueboxes)
+ op0 = create_resop_dispatch(opnum, result, valueboxes,
+ mutable=True)
if result is None:
results = []
else:
results = [op0]
- op1 = create_resop(rop.FINISH, None, results, descr=BasicFailDescr(0))
+ op1 = create_resop(rop.FINISH, None, results, descr=BasicFailDescr(0),
+ mutable=True)
if op0.is_guard():
- op0.set_extra("failargs", [])
+ op0.setfailargs([])
if not descr:
descr = BasicFailDescr(1)
if descr is not None:
op0.setdescr(descr)
- inputargs = []
+ inputargs = [box for box in valueboxes if not box.is_constant()]
return inputargs, [op0, op1]
class BaseBackendTest(Runner):
@@ -521,10 +525,10 @@
# last, try it with one constant argument
calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, EffectInfo.MOST_GENERAL)
- res = self.execute_operation(rop.CALL,
- [funcbox, ConstInt(num), BoxInt(num)],
+ res = self.execute_operation(rop.CALL_i,
+ [funcbox, ConstInt(num), boxint(num)],
'int', descr=calldescr)
- assert res.value == 2 * num
+ assert res == 2 * num
if cpu.supports_floats:
@@ -579,8 +583,8 @@
FPTR = self.Ptr(self.FuncType([TP, TP], TP))
func_ptr = llhelper(FPTR, f)
FUNC = deref(FPTR)
- funcconst = self.get_funcbox(self.cpu, func_ptr)
- funcbox = funcconst.nonconstbox()
+ funcbox = create_resop_0(rop.INPUT_i,
+ rffi.cast(lltype.Signed, func_ptr))
calldescr = self.cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
res = self.execute_operation(rop.CALL_i,
@@ -671,7 +675,7 @@
assert res is None
res = self.execute_operation(rop.GETFIELD_GC_r, [t_box],
'ref', descr=fielddescr2)
- assert res == u_box.value
+ assert res == u_box.getref_base()
#
null_const = self.null_instance().constbox()
res = self.execute_operation(rop.SETFIELD_GC, [t_box, null_const],
@@ -754,7 +758,7 @@
def test_ooops(self):
def clone(box):
- return boxptr(box.value)
+ return boxptr(box.getref_base())
u1_box, U_box = self.alloc_instance(self.U)
u2_box, U_box = self.alloc_instance(self.U)
@@ -788,9 +792,9 @@
# These operations are supposed to be the same as PTR_EQ/PTR_NE
# just checking that the operations are defined in the backend.
r = self.execute_operation(rop.INSTANCE_PTR_EQ, [u1_box, u2_box], 'int')
- assert r.value == 0
+ assert r == 0
r = self.execute_operation(rop.INSTANCE_PTR_NE, [u2_box, u1_box], 'int')
- assert r.value == 1
+ assert r == 1
def test_array_basic(self):
a_box, A = self.alloc_array_of(rffi.SHORT, 342)
@@ -859,7 +863,7 @@
assert r is None
r = self.execute_operation(rop.GETARRAYITEM_GC_r, [b_box, boxint(1)],
'ref', descr=arraydescr)
- assert r == a_box.value
+ assert r == a_box.getref_base()
#
# Unsigned should work the same as Signed
a_box, A = self.alloc_array_of(lltype.Unsigned, 342)
@@ -1090,9 +1094,9 @@
assert r == 5
u_box = self.alloc_unicode(u"hello\u1234")
r = self.execute_operation(rop.SAME_AS_r, [u_box.constbox()], 'ref')
- assert r == u_box.value
+ assert r == u_box.getref_base()
r = self.execute_operation(rop.SAME_AS_r, [u_box], 'ref')
- assert r == u_box.value
+ assert r == u_box.getref_base()
if self.cpu.supports_floats:
r = self.execute_operation(rop.SAME_AS_f, [constfloat(5.5)], 'float')
@@ -1122,7 +1126,7 @@
inputargs.append(boxint())
values.append(r.randrange(-100000, 100000))
else:
- inputargs.append(BoxFloat())
+ inputargs.append(boxfloat())
values.append(longlong.getfloatstorage(r.random()))
#
looptoken = JitCellToken()
@@ -1134,7 +1138,7 @@
ks = range(nb_args)
random.shuffle(ks)
for k in ks:
- if isinstance(inputargs[k], boxint):
+ if inputargs[k].type == INT:
x = r.randrange(-100000, 100000)
operations.append(
create_resop_2(rop.INT_ADD, 0, inputargs[k],
@@ -1154,7 +1158,8 @@
retvalues.insert(kk, y)
#
operations.append(
- create_resop(rop.FINISH, None, [], descr=faildescr)
+ create_resop(rop.FINISH, None, [], descr=faildescr,
+ mutable=True)
)
operations[-1].setfailargs(retboxes)
print inputargs
@@ -1224,20 +1229,19 @@
values = []
S = lltype.GcStruct('S')
for box in inpargs:
- if isinstance(box, boxint):
+ if box.type == INT:
values.append(r.randrange(-10000, 10000))
- elif isinstance(box, boxptr):
+ elif box.type == REF:
p = lltype.malloc(S)
values.append(lltype.cast_opaque_ptr(llmemory.GCREF, p))
- elif isinstance(box, BoxFloat):
+ elif box.type == FLOAT:
values.append(longlong.getfloatstorage(r.random()))
else:
assert 0
values[index_counter] = 11
#
frame = self.cpu.execute_token(looptoken, *values)
- assert self.cpu.get_latest_descr(frame).identifier == 15
- assert fail.identifier == 1
+ assert self.cpu.get_latest_descr(frame).identifier == 1
#
dstvalues = values[:]
for _ in range(11):
@@ -1302,7 +1306,7 @@
def test_compile_bridge_spilled_float(self):
if not self.cpu.supports_floats:
py.test.skip("requires floats")
- fboxes = [BoxFloat() for i in range(3)]
+ fboxes = [boxfloat() for i in range(3)]
faildescr1 = BasicFailDescr(100)
loopops = """
[i0,f1, f2]
@@ -1310,9 +1314,10 @@
force_spill(f3)
force_spill(f1)
force_spill(f2)
- guard_false(i0) [f1, f2, f3]
+ guard_false(i0, descr=faildescr0) [f1, f2, f3]
finish() []"""
- loop = parse(loopops)
+ loop = parse(loopops, guards_with_failargs=True,
+ namespace={'faildescr0': BasicFailDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
args = [1]
@@ -1328,7 +1333,8 @@
assert longlong.getrealfloat(f3) == 133.0
bridgeops = [
- ResOperation(rop.FINISH, [], None, descr=faildescr1),
+ create_resop(rop.FINISH, None, [], descr=faildescr1,
+ mutable=True),
]
bridgeops[-1].setfailargs(fboxes)
self.cpu.compile_bridge(loop.operations[-2].getdescr(), fboxes,
@@ -1353,19 +1359,18 @@
(rop.GUARD_FALSE, False),
(rop.GUARD_TRUE, True),
]:
- box = BoxInt()
- res = BoxInt()
+ box = boxint()
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
inputargs = [box]
- operations = [
- ResOperation(opname, [box], res),
- ResOperation(opguard, [res], None, descr=faildescr1),
- ResOperation(rop.FINISH, [], None, descr=faildescr2),
- ]
- operations[1].setfailargs([])
+ op0 = create_resop_1(opname, 0, box)
+ op1 = create_resop_1(opguard, None, op0, mutable=True)
+ op1.setdescr(faildescr1)
+ op1.setfailargs([])
+ op2 = create_resop(rop.FINISH, None, [], descr=faildescr2,
+ mutable=True)
looptoken = JitCellToken()
- self.cpu.compile_loop(inputargs, operations, looptoken)
+ self.cpu.compile_loop(inputargs, [op0, op1, op2], looptoken)
#
cpu = self.cpu
for value in [-42, 0, 1, 10]:
@@ -1402,12 +1407,13 @@
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
inputargs = [ib for ib in [ibox1, ibox2]
- if isinstance(ib, boxint)]
+ if not ib.is_constant()]
op0 = create_resop_2(opname, 0, ibox1, ibox2)
- op1 = create_resop_1(opguard, None, op0)
+ op1 = create_resop_1(opguard, None, op0, mutable=True)
op1.setdescr(faildescr1)
- op2 = create_resop(rop.FINISH, None, [], descr=faildescr2)
- op1.set_extra("failargs", [])
+ op1.setfailargs([])
+ op2 = create_resop(rop.FINISH, None, [], descr=faildescr2,
+ mutable=True)
operations = [op0, op1, op2]
looptoken = JitCellToken()
self.cpu.compile_loop(inputargs, operations, looptoken)
@@ -1443,26 +1449,25 @@
for combinaison in ["bb", "bc", "cb"]:
#
if combinaison[0] == 'b':
- ibox1 = BoxInt()
+ ibox1 = boxint()
else:
ibox1 = ConstInt(42)
if combinaison[1] == 'b':
- ibox2 = BoxInt()
+ ibox2 = boxint()
else:
ibox2 = ConstInt(42)
- b1 = BoxInt()
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
inputargs = [ib for ib in [ibox1, ibox2]
- if isinstance(ib, BoxInt)]
- operations = [
- ResOperation(opname, [ibox1, ibox2], b1),
- ResOperation(opguard, [b1], None, descr=faildescr1),
- ResOperation(rop.FINISH, [], None, descr=faildescr2),
- ]
- operations[-2].setfailargs([])
+ if not ib.is_constant()]
+ op0 = create_resop_2(opname, 0, ibox1, ibox2)
+ op1 = create_resop_1(opguard, None, op0, descr=faildescr1,
+ mutable=True)
+ op1.setfailargs([])
+ op2 = create_resop(rop.FINISH, None, [], descr=faildescr2,
+ mutable=True)
looptoken = JitCellToken()
- self.cpu.compile_loop(inputargs, operations, looptoken)
+ self.cpu.compile_loop(inputargs, [op0, op1, op2], looptoken)
#
cpu = self.cpu
for test1 in [65, 42, 11, 0, 1]:
@@ -1499,22 +1504,23 @@
for combinaison in ["bb", "bc", "cb"]:
#
if combinaison[0] == 'b':
- fbox1 = BoxFloat()
+ fbox1 = boxfloat()
else:
fbox1 = constfloat(-4.5)
if combinaison[1] == 'b':
- fbox2 = BoxFloat()
+ fbox2 = boxfloat()
else:
fbox2 = constfloat(-4.5)
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
inputargs = [fb for fb in [fbox1, fbox2]
- if isinstance(fb, BoxFloat)]
+ if not fb.is_constant()]
op0 = create_resop_2(opname, 0, fbox1, fbox2)
- op1 = create_resop_1(opguard, None, op0)
+ op1 = create_resop_1(opguard, None, op0, mutable=True)
op1.setdescr(faildescr1)
- op1.set_extra("failargs", [])
- op2 = create_resop(rop.FINISH, None, [], descr=faildescr2)
+ op1.setfailargs([])
+ op2 = create_resop(rop.FINISH, None, [], descr=faildescr2,
+ mutable=True)
operations = [op0, op1, op2]
looptoken = JitCellToken()
self.cpu.compile_loop(inputargs, operations, looptoken)
@@ -1561,28 +1567,29 @@
inputargs = []
operations = []
for opnum, boxargs, rettype, retvalue in tests:
- inputargs += [box for box in boxargs if isinstance(box, Box)]
+ inputargs += [box for box in boxargs if not box.is_constant()]
if rettype == 'int':
res = 0
elif rettype == 'float':
res = 0.0
else:
assert 0
- operations.append(create_resop_dispatch(opnum, res, boxargs))
+ operations.append(create_resop_dispatch(opnum, res, boxargs,
+ mutable=True))
# Unique-ify inputargs
inputargs = list(set(inputargs))
faildescr = BasicFailDescr(1)
operations.append(create_resop(rop.FINISH, None, [],
- descr=faildescr))
+ descr=faildescr, mutable=True))
looptoken = JitCellToken()
#
self.cpu.compile_loop(inputargs, operations, looptoken)
#
args = []
for box in inputargs:
- if isinstance(box, boxint):
+ if box.type == INT:
args.append(box.getint())
- elif isinstance(box, BoxFloat):
+ elif box.type == FLOAT:
args.append(box.getfloatstorage())
else:
assert 0
@@ -1624,8 +1631,6 @@
ok = isnan(got)
elif isinf(expected):
ok = isinf(got)
- elif isinstance(got, BoxFloat):
- ok = got == expected
else:
ok = got == expected
if not ok:
@@ -1638,11 +1643,13 @@
for guard_opnum, expected_id in [(rop.GUARD_TRUE, 1),
(rop.GUARD_FALSE, 0)]:
op0 = create_resop_2(opnum, 0, *testcase)
- op1 = create_resop_1(guard_opnum, None, op0)
+ op1 = create_resop_1(guard_opnum, None, op0,
+ mutable=True)
+ op1.setfailargs([])
op1.setdescr(BasicFailDescr(4))
op2 = create_resop(rop.FINISH, None, [],
- descr=BasicFailDescr(5))
- op1.set_extra("failargs", [])
+ descr=BasicFailDescr(5),
+ mutable=True)
operations = [op0, op1, op2]
looptoken = JitCellToken()
# Use "set" to unique-ify inputargs
@@ -1877,7 +1884,7 @@
r = self.execute_operation(rop.GETFIELD_GC_i, [boxptr(r1)], 'int',
descr=descrshort)
assert r == 1333
- t = lltype.cast_opaque_ptr(lltype.Ptr(self.T), t_box.value)
+ t = lltype.cast_opaque_ptr(lltype.Ptr(self.T), t_box.getref_base())
assert s.parent.parent.typeptr == t.parent.parent.typeptr
def test_new_array(self):
@@ -1916,7 +1923,7 @@
ops = '''
[i0]
i1 = same_as_i(1)
- call_n(ConstClass(fptr), i0, descr=calldescr)
+ call_v(ConstClass(fptr), i0, descr=calldescr)
p0 = guard_exception(ConstClass(xtp), descr=faildescr2) [i1]
finish(0, p0, descr=faildescr1) []
'''
@@ -1937,7 +1944,8 @@
exc_ptr = xptr
faildescr1 = BasicFailDescr(1)
faildescr2 = BasicFailDescr(2)
- loop = parse(ops, self.cpu, namespace=locals())
+ loop = parse(ops, self.cpu, namespace=locals(),
+ guards_with_failargs=True)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
frame = self.cpu.execute_token(looptoken, 1)
@@ -3222,7 +3230,7 @@
calldescr = self.cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
funcbox = self.get_funcbox(self.cpu, f)
- res = self.execute_operation(rop.CALL, [funcbox, BoxFloat(value)],
+ res = self.execute_operation(rop.CALL, [funcbox, boxfloat(value)],
'float', descr=calldescr)
assert res.getfloatstorage() == expected
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -1492,7 +1492,7 @@
v = Variable('new_length')
v.concretetype = lltype.Signed
ops.append(SpaceOperation('int_force_ge_zero', [v_length], v))
- ops.append(SpaceOperation('new_array', [arraydescr, v], op.result))
+ ops.append(SpaceOperation('new_array', [v, arraydescr], op.result))
return ops
def do_fixed_list_len(self, op, args, arraydescr):
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -1119,8 +1119,8 @@
return cpu.bh_call_v(jitcode.get_fnaddr_as_int(),
args_i, args_r, args_f, jitcode.calldescr)
- @arguments("cpu", "d", "i", returns="r")
- def bhimpl_new_array(cpu, arraydescr, length):
+ @arguments("cpu", "i", "d", returns="r")
+ def bhimpl_new_array(cpu, length, arraydescr):
return cpu.bh_new_array(length, arraydescr)
@arguments("cpu", "r", "i", "d", returns="i")
diff --git a/pypy/jit/metainterp/executor.py b/pypy/jit/metainterp/executor.py
--- a/pypy/jit/metainterp/executor.py
+++ b/pypy/jit/metainterp/executor.py
@@ -80,19 +80,19 @@
do_call_i = new_do_call(rop.CALL_i, 'i')
do_call_f = new_do_call(rop.CALL_f, 'f')
do_call_r = new_do_call(rop.CALL_r, 'r')
-do_call_n = new_do_call(rop.CALL_N, 'N')
+do_call_v = new_do_call(rop.CALL_v, 'v')
do_call_loopinvariant_i = new_do_call(rop.CALL_LOOPINVARIANT_i, 'i')
do_call_loopinvariant_f = new_do_call(rop.CALL_LOOPINVARIANT_f, 'f')
do_call_loopinvariant_r = new_do_call(rop.CALL_LOOPINVARIANT_r, 'r')
-do_call_loopinvariant_n = new_do_call(rop.CALL_LOOPINVARIANT_N, 'N')
+do_call_loopinvariant_v = new_do_call(rop.CALL_LOOPINVARIANT_v, 'v')
do_call_may_force_i = new_do_call(rop.CALL_MAY_FORCE_i, 'i')
do_call_may_force_f = new_do_call(rop.CALL_MAY_FORCE_f, 'f')
do_call_may_force_r = new_do_call(rop.CALL_MAY_FORCE_r, 'r')
-do_call_may_force_n = new_do_call(rop.CALL_MAY_FORCE_N, 'N')
+do_call_may_force_v = new_do_call(rop.CALL_MAY_FORCE_v, 'v')
do_call_pure_i = new_do_call(rop.CALL_PURE_i, 'i')
do_call_pure_f = new_do_call(rop.CALL_PURE_f, 'f')
do_call_pure_r = new_do_call(rop.CALL_PURE_r, 'r')
-do_call_pure_n = new_do_call(rop.CALL_PURE_N, 'N')
+do_call_pure_v = new_do_call(rop.CALL_PURE_v, 'v')
def do_setarrayitem_gc(cpu, _, arraybox, indexbox, itembox, arraydescr):
array = arraybox.getref_base()
@@ -323,40 +323,25 @@
rop.CALL_ASSEMBLER_i,
rop.CALL_ASSEMBLER_r,
rop.CALL_ASSEMBLER_f,
- rop.CALL_ASSEMBLER_N,
+ rop.CALL_ASSEMBLER_v,
rop.COND_CALL_GC_WB,
rop.COND_CALL_GC_WB_ARRAY,
rop.DEBUG_MERGE_POINT,
rop.JIT_DEBUG,
rop.SETARRAYITEM_RAW,
rop.GETINTERIORFIELD_RAW_i,
- rop.GETINTERIORFIELD_RAW_r,
rop.GETINTERIORFIELD_RAW_f,
- rop.GETINTERIORFIELD_RAW_N,
rop.SETINTERIORFIELD_RAW,
rop.CALL_RELEASE_GIL_i,
rop.CALL_RELEASE_GIL_r,
rop.CALL_RELEASE_GIL_f,
- rop.CALL_RELEASE_GIL_N,
+ rop.CALL_RELEASE_GIL_v,
rop.QUASIIMMUT_FIELD,
rop.CALL_MALLOC_GC,
rop.CALL_MALLOC_NURSERY,
rop.LABEL,
- rop.GETARRAYITEM_RAW_PURE_N,
- rop.GETFIELD_RAW_r,
- rop.GETARRAYITEM_RAW_PURE_r,
- rop.SAME_AS_N,
- rop.GETINTERIORFIELD_GC_N,
- rop.GETFIELD_RAW_N,
- rop.GETFIELD_RAW_PURE_N,
- rop.GETFIELD_RAW_PURE_r,
- rop.GETARRAYITEM_RAW_N,
- rop.GETFIELD_GC_PURE_N,
- rop.GETARRAYITEM_GC_PURE_N,
- rop.GETARRAYITEM_GC_N,
- rop.GETFIELD_GC_N,
- rop.GETARRAYITEM_RAW_r,
- rop.RAW_LOAD_N,
+ rop.INPUT_i, rop.INPUT_r, rop.INPUT_f,
+ rop.FORCE_SPILL, rop.ESCAPE,
): # list of opcodes never executed by pyjitpl
continue
raise AssertionError("missing %r" % (orig_key,))
diff --git a/pypy/jit/metainterp/logger.py b/pypy/jit/metainterp/logger.py
--- a/pypy/jit/metainterp/logger.py
+++ b/pypy/jit/metainterp/logger.py
@@ -2,7 +2,7 @@
from pypy.rlib.debug import debug_start, debug_stop, debug_print
from pypy.rlib.objectmodel import we_are_translated
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
-from pypy.jit.metainterp.resoperation import rop, ConstInt, BoxInt, BoxFloat
+from pypy.jit.metainterp.resoperation import rop, ConstInt
from pypy.jit.metainterp.history import TargetToken
class Logger(object):
diff --git a/pypy/jit/metainterp/optimizeopt/optimizer.py b/pypy/jit/metainterp/optimizeopt/optimizer.py
--- a/pypy/jit/metainterp/optimizeopt/optimizer.py
+++ b/pypy/jit/metainterp/optimizeopt/optimizer.py
@@ -13,8 +13,7 @@
from pypy.jit.metainterp import jitprof, resume, compile
from pypy.jit.metainterp.executor import execute_nonspec
-from pypy.jit.metainterp.resoperation import BoxInt, BoxFloat, REF, INT,\
- create_resop_1
+from pypy.jit.metainterp.resoperation import REF, INT, create_resop_1
from pypy.jit.metainterp.optimizeopt.intutils import IntBound, IntUnbounded, \
ImmutableIntUnbounded, \
IntLowerBound, MININT, MAXINT
diff --git a/pypy/jit/metainterp/optimizeopt/pure.py b/pypy/jit/metainterp/optimizeopt/pure.py
--- a/pypy/jit/metainterp/optimizeopt/pure.py
+++ b/pypy/jit/metainterp/optimizeopt/pure.py
@@ -77,7 +77,7 @@
optimize_CALL_PURE_i = _new_optimize_call_pure(rop.CALL_i)
optimize_CALL_PURE_f = _new_optimize_call_pure(rop.CALL_f)
optimize_CALL_PURE_r = _new_optimize_call_pure(rop.CALL_r)
- optimize_CALL_PURE_N = _new_optimize_call_pure(rop.CALL_N)
+ optimize_CALL_PURE_v = _new_optimize_call_pure(rop.CALL_v)
def optimize_GUARD_NO_EXCEPTION(self, op):
if self.last_emitted_operation is REMOVED:
diff --git a/pypy/jit/metainterp/optimizeopt/rewrite.py b/pypy/jit/metainterp/optimizeopt/rewrite.py
--- a/pypy/jit/metainterp/optimizeopt/rewrite.py
+++ b/pypy/jit/metainterp/optimizeopt/rewrite.py
@@ -349,7 +349,7 @@
optimize_CALL_LOOPINVARIANT_i = _new_optimize_call_loopinvariant(rop.CALL_i)
optimize_CALL_LOOPINVARIANT_r = _new_optimize_call_loopinvariant(rop.CALL_r)
optimize_CALL_LOOPINVARIANT_f = _new_optimize_call_loopinvariant(rop.CALL_f)
- optimize_CALL_LOOPINVARIANT_N = _new_optimize_call_loopinvariant(rop.CALL_N)
+ optimize_CALL_LOOPINVARIANT_v = _new_optimize_call_loopinvariant(rop.CALL_v)
def _optimize_nullness(self, op, box, expect_nonnull):
value = self.getvalue(box)
@@ -434,7 +434,7 @@
self.emit_operation(op)
optimize_CALL_p = optimize_CALL_i
optimize_CALL_f = optimize_CALL_i
- optimize_CALL_N = optimize_CALL_i
+ optimize_CALL_v = optimize_CALL_i
def _optimize_CALL_ARRAYCOPY(self, op):
source_value = self.getvalue(op.getarg(1))
@@ -482,7 +482,7 @@
self.emit_operation(op)
optimize_CALL_PURE_f = optimize_CALL_PURE_i
optimize_CALL_PURE_p = optimize_CALL_PURE_i
- optimize_CALL_PURE_N = optimize_CALL_PURE_i
+ optimize_CALL_PURE_v = optimize_CALL_PURE_i
def optimize_GUARD_NO_EXCEPTION(self, op):
if self.last_emitted_operation is REMOVED:
diff --git a/pypy/jit/metainterp/optimizeopt/simplify.py b/pypy/jit/metainterp/optimizeopt/simplify.py
--- a/pypy/jit/metainterp/optimizeopt/simplify.py
+++ b/pypy/jit/metainterp/optimizeopt/simplify.py
@@ -14,12 +14,12 @@
self.emit_operation(op.copy_and_change(getattr(rop, 'CALL_' + tp)))
optimize_CALL_PURE_i = _new_optimize_call('i')
optimize_CALL_PURE_f = _new_optimize_call('f')
- optimize_CALL_PURE_N = _new_optimize_call('N')
- optimize_CALL_PURE_p = _new_optimize_call('p')
+ optimize_CALL_PURE_v = _new_optimize_call('v')
+ optimize_CALL_PURE_r = _new_optimize_call('r')
optimize_CALL_LOOPINVARIANT_i = _new_optimize_call('i')
optimize_CALL_LOOPINVARIANT_f = _new_optimize_call('f')
- optimize_CALL_LOOPINVARIANT_N = _new_optimize_call('N')
- optimize_CALL_LOOPINVARIANT_p = _new_optimize_call('p')
+ optimize_CALL_LOOPINVARIANT_v = _new_optimize_call('v')
+ optimize_CALL_LOOPINVARIANT_r = _new_optimize_call('r')
def optimize_VIRTUAL_REF_FINISH(self, op):
pass
diff --git a/pypy/jit/metainterp/optimizeopt/util.py b/pypy/jit/metainterp/optimizeopt/util.py
--- a/pypy/jit/metainterp/optimizeopt/util.py
+++ b/pypy/jit/metainterp/optimizeopt/util.py
@@ -32,11 +32,7 @@
def make_dispatcher_method(Class, name_prefix, op_prefix=None, default=None):
ops = _findall(Class, name_prefix, op_prefix)
def dispatch(self, op, *args):
-<<<<<<< local
- if we_are_translated() or op.getopnum() < 0:
-=======
if we_are_translated():
->>>>>>> other
opnum = op.getopnum()
for value, cls, func in ops:
if opnum == value:
@@ -45,20 +41,12 @@
if default:
return default(self, op, *args)
else:
-<<<<<<< local
name = resoperation.opname[op.getopnum()]
func = getattr(Class, name_prefix + name, None)
-=======
- func = getattr(Class, name_prefix + op.getopname().upper(), None)
->>>>>>> other
if func is not None:
return func(self, op, *args)
if default:
return default(self, op, *args)
-<<<<<<< local
-
-=======
->>>>>>> other
dispatch.func_name = "dispatch_" + name_prefix
return dispatch
diff --git a/pypy/jit/metainterp/optimizeopt/virtualize.py b/pypy/jit/metainterp/optimizeopt/virtualize.py
--- a/pypy/jit/metainterp/optimizeopt/virtualize.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualize.py
@@ -3,7 +3,7 @@
from pypy.jit.metainterp.optimizeopt import optimizer
from pypy.jit.metainterp.optimizeopt.util import (make_dispatcher_method,
descrlist_dict, sort_descrs)
-from pypy.jit.metainterp.resoperation import rop, Const, ConstInt, BoxInt,\
+from pypy.jit.metainterp.resoperation import rop, Const, ConstInt,\
create_resop_2, create_resop_3, create_resop_1, create_resop_0
from pypy.rlib.objectmodel import we_are_translated
from pypy.jit.metainterp.optimizeopt.optimizer import OptValue
@@ -387,21 +387,13 @@
# Replace the VIRTUAL_REF operation with a virtual structure of type
# 'jit_virtual_ref'. The jit_virtual_ref structure may be forced soon,
# but the point is that doing so does not force the original structure.
-<<<<<<< local
new_op = create_resop_1(rop.NEW_WITH_VTABLE, llhelper.NULLREF,
c_cls)
self.replace(op, new_op)
vrefvalue = self.make_virtual(c_cls, new_op)
- token_op = create_resop_0(rop.FORCE_TOKEN, 0)
+ token_op = create_resop_0(rop.JIT_FRAME, 0)
self.emit_operation(token_op)
- vrefvalue.setfield(descr_virtual_token, self.getvalue(token_op))
-=======
- op = ResOperation(rop.NEW_WITH_VTABLE, [c_cls], op.result)
- vrefvalue = self.make_virtual(c_cls, op.result, op)
- tokenbox = BoxPtr()
- self.emit_operation(ResOperation(rop.JIT_FRAME, [], tokenbox))
- vrefvalue.setfield(descr_jit_frame, self.getvalue(tokenbox))
->>>>>>> other
+ vrefvalue.setfield(descr_jit_frame, self.getvalue(token_op))
def optimize_VIRTUAL_REF_FINISH(self, op):
# This operation is used in two cases. In normal cases, it
@@ -426,17 +418,10 @@
seo(create_resop_2(rop.SETFIELD_GC, None, op.getarg(0),
op.getarg(1), descr=vrefinfo.descr_forced))
-<<<<<<< local
- # - set 'virtual_token' to TOKEN_NONE
+ # - set 'virtual_token' to TOKEN_NONE (== NULL)
seo(create_resop_2(rop.SETFIELD_GC, None, op.getarg(0),
ConstInt(vrefinfo.TOKEN_NONE),
- descr = vrefinfo.descr_virtual_token))
-=======
- # - set 'virtual_token' to TOKEN_NONE (== NULL)
- args = [op.getarg(0), self.optimizer.cpu.ts.CONST_NULL]
- seo(ResOperation(rop.SETFIELD_GC, args, None,
- descr = vrefinfo.descr_jit_frame))
->>>>>>> other
+ descr = vrefinfo.descr_jit_frame))
# Note that in some cases the virtual in op.getarg(1) has been forced
# already. This is fine. In that case, and *if* a residual
# CALL_MAY_FORCE suddenly turns out to access it, then it will
diff --git a/pypy/jit/metainterp/optimizeopt/virtualstate.py b/pypy/jit/metainterp/optimizeopt/virtualstate.py
--- a/pypy/jit/metainterp/optimizeopt/virtualstate.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualstate.py
@@ -6,8 +6,7 @@
LEVEL_UNKNOWN
from pypy.jit.metainterp.optimize import InvalidLoop
from pypy.jit.metainterp.optimizeopt.intutils import IntUnbounded
-from pypy.jit.metainterp.resoperation import rop, Const, ConstInt, BoxInt,\
- BoxPtr
+from pypy.jit.metainterp.resoperation import rop, Const, ConstInt
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.debug import debug_start, debug_stop, debug_print
diff --git a/pypy/jit/metainterp/optimizeopt/vstring.py b/pypy/jit/metainterp/optimizeopt/vstring.py
--- a/pypy/jit/metainterp/optimizeopt/vstring.py
+++ b/pypy/jit/metainterp/optimizeopt/vstring.py
@@ -541,12 +541,12 @@
self.emit_operation(op)
optimize_CALL_f = optimize_CALL_i
optimize_CALL_r = optimize_CALL_i
- optimize_CALL_N = optimize_CALL_i
+ optimize_CALL_v = optimize_CALL_i
optimize_CALL_PURE_i = optimize_CALL_i
optimize_CALL_PURE_f = optimize_CALL_i
optimize_CALL_PURE_p = optimize_CALL_i
- optimize_CALL_PURE_N = optimize_CALL_i
+ optimize_CALL_PURE_v = optimize_CALL_i
def optimize_GUARD_NO_EXCEPTION(self, op):
if self.last_emitted_operation is REMOVED:
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -11,7 +11,7 @@
ConstFloat
from pypy.jit.metainterp.history import TargetToken
from pypy.jit.metainterp.resoperation import rop, create_resop, create_resop_0,\
- create_resop_1, create_resop_2, Box
+ create_resop_1, create_resop_2
from pypy.jit.metainterp import resoperation
from pypy.jit.metainterp import executor
from pypy.jit.metainterp.logger import Logger
@@ -1538,25 +1538,6 @@
self.callinfocollection = codewriter.callcontrol.callinfocollection
self.has_libffi_call = codewriter.callcontrol.has_libffi_call
#
-<<<<<<< local
- # store this information for fastpath of call_assembler
- # (only the paths that can actually be taken)
- for jd in self.jitdrivers_sd:
- name = {resoperation.INT: 'int',
- resoperation.REF: 'ref',
- resoperation.FLOAT: 'float',
- resoperation.VOID: 'void'}[jd.result_type]
- tokens = getattr(self, 'loop_tokens_done_with_this_frame_%s' % name)
- jd.portal_finishtoken = tokens[0].finishdescr
- num = self.cpu.get_fail_descr_number(tokens[0].finishdescr)
- setattr(self.cpu, 'done_with_this_frame_%s_v' % name, num)
- #
-=======
->>>>>>> other
- exc_descr = compile.PropagateExceptionDescr()
- num = self.cpu.get_fail_descr_number(exc_descr)
- self.cpu.propagate_exception_v = num
- #
self.globaldata = MetaInterpGlobalData(self)
def _setup_once(self):
@@ -2248,19 +2229,6 @@
result_type = self.jitdriver_sd.result_type
if result_type == resoperation.VOID:
assert exitbox is None
-<<<<<<< local
- exits = []
- loop_tokens = sd.loop_tokens_done_with_this_frame_void
- elif result_type == resoperation.INT:
- exits = [exitbox]
- loop_tokens = sd.loop_tokens_done_with_this_frame_int
- elif result_type == resoperation.REF:
- exits = [exitbox]
- loop_tokens = sd.loop_tokens_done_with_this_frame_ref
- elif result_type == resoperation.FLOAT:
- exits = [exitbox]
- loop_tokens = sd.loop_tokens_done_with_this_frame_float
-=======
self.compile_done([], compile.DoneWithThisFrameDescrVoid)
elif result_type == history.INT:
self.compile_done([exitbox], compile.DoneWithThisFrameDescrInt)
@@ -2268,15 +2236,8 @@
self.compile_done([exitbox], compile.DoneWithThisFrameDescrRef)
elif result_type == history.FLOAT:
self.compile_done([exitbox], compile.DoneWithThisFrameDescrFloat)
->>>>>>> other
else:
assert False
-<<<<<<< local
- # FIXME: kill TerminatingLoopToken?
- # FIXME: can we call compile_trace?
- token = loop_tokens[0].finishdescr
- self.history.record(create_resop(rop.FINISH, None, exits, descr=token))
-=======
def compile_exit_frame_with_exception(self, valuebox):
self.compile_done([valuebox], compile.ExitFrameWithExceptionDescrRef)
@@ -2291,7 +2252,6 @@
token = DoneCls(self.staticdata, self.jitdriver_sd)
resume.capture_resumedata([], virtualizable_boxes, [], token)
self.history.record(rop.FINISH, exits, None, descr=token)
->>>>>>> other
target_token = compile.compile_trace(self, self.resumekey)
if target_token is None:
compile.giveup()
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -72,8 +72,6 @@
assert _arg.type != VOID
op._args = args
if descr is not None:
- assert isinstance(op, ResOpWithDescr)
- assert not op.is_guard()
op.setdescr(descr)
return op
@@ -88,8 +86,6 @@
else:
op = cls(result)
if descr is not None:
- assert isinstance(op, ResOpWithDescr)
- assert not op.is_guard()
op.setdescr(descr)
return op
@@ -110,8 +106,6 @@
assert arg0.type != VOID
op._arg0 = arg0
if descr is not None:
- assert isinstance(op, ResOpWithDescr)
- assert not op.is_guard()
op.setdescr(descr)
return op
@@ -133,8 +127,6 @@
op._arg0 = arg0
op._arg1 = arg1
if descr is not None:
- assert isinstance(op, ResOpWithDescr)
- assert not op.is_guard()
op.setdescr(descr)
return op
@@ -158,8 +150,6 @@
op._arg1 = arg1
op._arg2 = arg2
if descr is not None:
- assert isinstance(op, ResOpWithDescr)
- assert not op.is_guard()
op.setdescr(descr)
return op
@@ -211,12 +201,6 @@
"""
raise NotImplementedError
- def nonconstbox(self):
- """ Return a box value of the current constant wrapped in an
- apropriate box class
- """
- raise NotImplementedError
-
def getaddr(self):
raise NotImplementedError
@@ -351,9 +335,6 @@
assert isinstance(value, Symbolic)
self.value = value
- def nonconstbox(self):
- return BoxInt(self.value)
-
def getint(self):
return self.value
@@ -392,9 +373,6 @@
assert lltype.typeOf(valuestorage) is longlong.FLOATSTORAGE
self.value = valuestorage
- def nonconstbox(self):
- return BoxFloat(self.value)
-
def getfloatstorage(self):
return self.value
@@ -430,9 +408,6 @@
assert lltype.typeOf(value) == llmemory.GCREF
self.value = value
- def nonconstbox(self):
- return BoxPtr(self.value)
-
def getref_base(self):
return self.value
@@ -496,9 +471,10 @@
return cls.opnum
def __hash__(self):
+ # XXX this is a hack kill me
import sys
co_fname = sys._getframe(1).f_code.co_filename
- if co_fname.endswith('resume.py') or co_fname.endswith('optimizeopt/util.py') or 'backend/llgraph' in co_fname:
+ if co_fname.endswith('resume.py') or co_fname.endswith('optimizeopt/util.py') or 'backend/llgraph' in co_fname or 'backend/test' in co_fname:
return object.__hash__(self)
raise Exception("Should not hash resops, use get/set extra instead")
@@ -702,7 +678,11 @@
type = INT
def __init__(self, intval):
- assert isinstance(intval, int)
+ if not we_are_translated():
+ if is_valid_int(intval):
+ intval = int(intval)
+ else:
+ assert isinstance(intval, Symbolic)
self.intval = intval
def getint(self):
@@ -1136,30 +1116,42 @@
# ____________________________________________________________
_oplist = [
+ # key:
+ # _<something> means just a marker
+ # OPNAME/<number-of-parameters-or-*>[d]/T
+ # where:
+ # "*" in parameter list means any number
+ # "d" means if there is a descr associated with a resop
+ # T can be one of "r", "i", "f", "v", "*" or "?"
+ # "r", "i", "f" - normal return, appropriate type
+ # "v" - void return type
+ # "*" - four variants will be generated, "r", "i", "f", "v"
+ # "?" - three variants will be generated, "r", "i", "f"
+
'_FINAL_FIRST',
- 'JUMP/*d/N',
- 'FINISH/*d/N',
+ 'JUMP/*d/v',
+ 'FINISH/*d/v',
'_FINAL_LAST',
- 'LABEL/*d/N',
- 'INPUT/0/*',
+ 'LABEL/*d/v',
+ 'INPUT/0/?',
'_GUARD_FIRST',
'_GUARD_FOLDABLE_FIRST',
- 'GUARD_TRUE/1/N',
- 'GUARD_FALSE/1/N',
- 'GUARD_VALUE/2/N',
- 'GUARD_CLASS/2/N',
- 'GUARD_NONNULL/1/N',
- 'GUARD_ISNULL/1/N',
- 'GUARD_NONNULL_CLASS/2/N',
+ 'GUARD_TRUE/1/v',
+ 'GUARD_FALSE/1/v',
+ 'GUARD_VALUE/2/v',
+ 'GUARD_CLASS/2/v',
+ 'GUARD_NONNULL/1/v',
+ 'GUARD_ISNULL/1/v',
+ 'GUARD_NONNULL_CLASS/2/v',
'_GUARD_FOLDABLE_LAST',
- 'GUARD_NO_EXCEPTION/0/N', # may be called with an exception currently set
+ 'GUARD_NO_EXCEPTION/0/v', # may be called with an exception currently set
'GUARD_EXCEPTION/1/r', # may be called with an exception currently set
- 'GUARD_NO_OVERFLOW/0/N',
- 'GUARD_OVERFLOW/0/N',
- 'GUARD_NOT_FORCED/0/N', # may be called with an exception currently set
- 'GUARD_NOT_INVALIDATED/0/N',
+ 'GUARD_NO_OVERFLOW/0/v',
+ 'GUARD_OVERFLOW/0/v',
+ 'GUARD_NOT_FORCED/0/v', # may be called with an exception currently set
+ 'GUARD_NOT_INVALIDATED/0/v',
'_GUARD_LAST', # ----- end of guard operations -----
'_NOSIDEEFFECT_FIRST', # ----- start of no_side_effect operations -----
@@ -1212,7 +1204,7 @@
'INT_INVERT/1/i',
'INT_FORCE_GE_ZERO/1/i',
#
- 'SAME_AS/1/*', # gets a Const or a Box, turns it into another Box
+ 'SAME_AS/1/?', # gets a Const or a Box, turns it into another Box
'_ALWAYS_PURE_NO_PTR_LAST',
'CAST_PTR_TO_INT/1/i',
'CAST_INT_TO_PTR/1/r',
@@ -1225,10 +1217,11 @@
'ARRAYLEN_GC/1d/i',
'STRLEN/1/i',
'STRGETITEM/2/i',
- 'GETFIELD_GC_PURE/1d/*',
- 'GETFIELD_RAW_PURE/1d/*',
- 'GETARRAYITEM_GC_PURE/2d/*',
- 'GETARRAYITEM_RAW_PURE/2d/*',
+ 'GETFIELD_GC_PURE/1d/?',
+ 'GETFIELD_RAW_PURE/1d/?',
+ 'GETARRAYITEM_GC_PURE/2d/?',
+ 'GETARRAYITEM_RAW_PURE_i/2d/i',
+ 'GETARRAYITEM_RAW_PURE_f/2d/f',
'UNICODELEN/1/i',
'UNICODEGETITEM/2/i',
#
@@ -1238,13 +1231,17 @@
#
'_ALWAYS_PURE_LAST', # ----- end of always_pure operations -----
- 'GETARRAYITEM_GC/2d/*',
- 'GETARRAYITEM_RAW/2d/*',
- 'GETINTERIORFIELD_GC/2d/*',
- 'GETINTERIORFIELD_RAW/2d/*',
- 'RAW_LOAD/2d/*',
- 'GETFIELD_GC/1d/*',
- 'GETFIELD_RAW/1d/*',
+ 'GETARRAYITEM_GC/2d/?',
+ 'GETARRAYITEM_RAW_i/2d/i',
+ 'GETARRAYITEM_RAW_f/2d/f',
+ 'GETINTERIORFIELD_GC/2d/?',
+ 'GETINTERIORFIELD_RAW_i/2d/i',
+ 'GETINTERIORFIELD_RAW_f/2d/f',
+ 'RAW_LOAD_i/2d/i',
+ 'RAW_LOAD_f/2d/f',
+ 'GETFIELD_GC/1d/?',
+ 'GETFIELD_RAW_i/1d/i',
+ 'GETFIELD_RAW_f/1d/f',
'_MALLOC_FIRST',
'NEW/0d/r',
'NEW_WITH_VTABLE/1/r',
@@ -1255,28 +1252,31 @@
'JIT_FRAME/0/r',
'VIRTUAL_REF/2/i', # removed before it's passed to the backend
'READ_TIMESTAMP/0/L', # float on 32bit, int on 64bit
- 'MARK_OPAQUE_PTR/1b/N',
+ 'MARK_OPAQUE_PTR/1b/v',
'_NOSIDEEFFECT_LAST', # ----- end of no_side_effect operations -----
- 'SETARRAYITEM_GC/3d/N',
- 'SETARRAYITEM_RAW/3d/N',
- 'SETINTERIORFIELD_GC/3d/N',
- 'SETINTERIORFIELD_RAW/3d/N', # only used by llsupport/rewrite.py
- 'RAW_STORE/3d/N',
- 'SETFIELD_GC/2d/N',
- 'SETFIELD_RAW/2d/N',
- 'STRSETITEM/3/N',
- 'UNICODESETITEM/3/N',
+ 'ESCAPE/1/v', # tests
+ 'FORCE_SPILL/1/v', # tests
+
+ 'SETARRAYITEM_GC/3d/v',
+ 'SETARRAYITEM_RAW/3d/v',
+ 'SETINTERIORFIELD_GC/3d/v',
+ 'SETINTERIORFIELD_RAW/3d/v', # only used by llsupport/rewrite.py
+ 'RAW_STORE/3d/v',
+ 'SETFIELD_GC/2d/v',
+ 'SETFIELD_RAW/2d/v',
+ 'STRSETITEM/3/v',
+ 'UNICODESETITEM/3/v',
#'RUNTIMENEW/1', # ootype operation
- 'COND_CALL_GC_WB/2d/N', # [objptr, newvalue] (for the write barrier)
- 'COND_CALL_GC_WB_ARRAY/3d/N', # [objptr, arrayindex, newvalue] (write barr.)
- 'DEBUG_MERGE_POINT/*/N', # debugging only
- 'JIT_DEBUG/*/N', # debugging only
- 'VIRTUAL_REF_FINISH/2/N', # removed before it's passed to the backend
- 'COPYSTRCONTENT/5/N', # src, dst, srcstart, dststart, length
- 'COPYUNICODECONTENT/5/N',
- 'QUASIIMMUT_FIELD/1d/N', # [objptr], descr=SlowMutateDescr
- 'RECORD_KNOWN_CLASS/2/N', # [objptr, clsptr]
+ 'COND_CALL_GC_WB/2d/v', # [objptr, newvalue] (for the write barrier)
+ 'COND_CALL_GC_WB_ARRAY/3d/v', # [objptr, arrayindex, newvalue] (write barr.)
+ 'DEBUG_MERGE_POINT/*/v', # debugging only
+ 'JIT_DEBUG/*/v', # debugging only
+ 'VIRTUAL_REF_FINISH/2/v', # removed before it's passed to the backend
+ 'COPYSTRCONTENT/5/v', # src, dst, srcstart, dststart, length
+ 'COPYUNICODECONTENT/5/v',
+ 'QUASIIMMUT_FIELD/1d/v', # [objptr], descr=SlowMutateDescr
+ 'RECORD_KNOWN_CLASS/2/v', # [objptr, clsptr]
'_CANRAISE_FIRST', # ----- start of can_raise operations -----
'_CALL_FIRST',
@@ -1336,7 +1336,7 @@
else:
arity = int(arity)
else:
- arity, withdescr, boolresult, tp = -1, True, False, "N" # default
+ arity, withdescr, boolresult, tp = -1, True, False, "v" # default
if not basename.startswith('_'):
clss = create_classes_for_op(basename, i, arity, withdescr, tp)
else:
@@ -1386,7 +1386,7 @@
3: TernaryOp
}
tpmixin = {
- 'N': ResOpNone,
+ 'v': ResOpNone,
'i': ResOpInt,
'f': ResOpFloat,
'r': ResOpPointer,
@@ -1401,15 +1401,19 @@
baseclass = PlainResOp
mixin = arity2mixin.get(arity, N_aryOp)
- if tp == '*':
+ if tp in '*?':
res = []
- for tp in ['f', 'r', 'i', 'N']:
+ if tp == '*':
+ lst = ['i', 'r', 'f', 'v']
+ else:
+ lst = ['i', 'r', 'f']
+ for tp in lst:
cls_name = '%s_OP_%s' % (name, tp)
bases = (get_base_class(mixin, tpmixin[tp], baseclass),)
dic = {'opnum': opnum}
res.append((type(cls_name, bases, dic), name + '_' + tp, tp))
opnum += 1
- return res
+ return res
else:
if tp == 'L':
if longlong.is_64_bit:
diff --git a/pypy/jit/metainterp/test/test_executor.py b/pypy/jit/metainterp/test/test_executor.py
--- a/pypy/jit/metainterp/test/test_executor.py
+++ b/pypy/jit/metainterp/test/test_executor.py
@@ -7,7 +7,7 @@
from pypy.jit.metainterp.resoperation import rop, opboolinvers, opboolreflex, opname
from pypy.jit.metainterp.history import AbstractDescr
from pypy.jit.metainterp.resoperation import ConstInt, ConstPtr, ConstFloat,\
- BoxInt, BoxPtr, BoxFloat
+ create_resop_0, example_for_opnum
from pypy.jit.metainterp import history
from pypy.jit.codewriter import longlong
from pypy.jit.backend.model import AbstractCPU
@@ -69,27 +69,34 @@
return 13
def boxfloat(x):
- return BoxFloat(longlong.getfloatstorage(x))
+ return create_resop_0(rop.INPUT_f, longlong.getfloatstorage(x))
def constfloat(x):
return ConstFloat(longlong.getfloatstorage(x))
+def boxint(x):
+ return create_resop_0(rop.INPUT_i, x)
+
+def boxptr(x=None):
+ if x is None:
+ x = example_for_opnum(rop.INPUT_r)
+ return create_resop_0(rop.INPUT_r, x)
def test_execute():
cpu = FakeCPU()
descr = FakeDescr()
- resop = execute(cpu, None, rop.INT_ADD, None, BoxInt(40), ConstInt(2))
+ resop = execute(cpu, None, rop.INT_ADD, None, boxint(40), ConstInt(2))
assert resop.intval == 42
resop = execute(cpu, None, rop.NEW, descr)
assert resop.pval.fakeargs == ('new', descr)
- execute(cpu, None, rop.JIT_DEBUG, None, BoxInt(1), BoxInt(2), BoxInt(3),
- BoxInt(4))
+ execute(cpu, None, rop.JIT_DEBUG, None, boxint(1), boxint(2), boxint(3),
+ boxint(4))
def test_execute_varargs():
cpu = FakeCPU()
descr = FakeCallDescr()
- argboxes = [BoxInt(99999), BoxInt(321), constfloat(2.25), ConstInt(123),
- BoxPtr(), boxfloat(5.5)]
+ argboxes = [boxint(99999), boxint(321), constfloat(2.25), ConstInt(123),
+ boxptr(), boxfloat(5.5)]
box = execute_varargs(cpu, FakeMetaInterp(), rop.CALL_f, argboxes, descr)
assert box.getfloat() == 42.5
assert cpu.fakecalled == (99999, descr, [321, 123],
@@ -102,7 +109,7 @@
descr = FakeDescr()
# cases with a descr
# arity == -1
- argboxes = [BoxInt(321), ConstInt(123)]
+ argboxes = [boxint(321), ConstInt(123)]
box = execute_nonspec(cpu, FakeMetaInterp(), rop.CALL_f,
argboxes, FakeCallDescr())
assert box.getfloat() == 42.5
@@ -110,7 +117,7 @@
box = execute_nonspec(cpu, None, rop.NEW, [], descr)
assert box.pval.fakeargs == ('new', descr)
# arity == 1
- box1 = BoxPtr()
+ box1 = boxptr()
box = execute_nonspec(cpu, None, rop.ARRAYLEN_GC, [box1], descr)
assert box.intval == 55
# arity == 2
@@ -119,7 +126,7 @@
execute_nonspec(cpu, None, rop.SETFIELD_GC, [box1, box2], fielddescr)
assert cpu.fakesetfield == (box1.value, box2.value, fielddescr)
# arity == 3
- box3 = BoxInt(33)
+ box3 = boxint(33)
arraydescr = FakeArrayDescr()
execute_nonspec(cpu, None, rop.SETARRAYITEM_GC, [box1, box3, box2],
arraydescr)
@@ -130,16 +137,16 @@
box = execute_nonspec(cpu, None, rop.INT_INVERT, [box3])
assert box.intval == ~33
# arity == 2
- box = execute_nonspec(cpu, None, rop.INT_LSHIFT, [box3, BoxInt(3)])
+ box = execute_nonspec(cpu, None, rop.INT_LSHIFT, [box3, boxint(3)])
assert box.intval == 33 << 3
# arity == 3
- execute_nonspec(cpu, None, rop.STRSETITEM, [box1, BoxInt(3), box3])
+ execute_nonspec(cpu, None, rop.STRSETITEM, [box1, boxint(3), box3])
assert cpu.fakestrsetitem == (box1.value, 3, box3.value)
def test_getarrayitems():
cpu = FakeCPU()
resop = execute_nonspec(cpu, None, rop.GETARRAYITEM_GC_i,
- [BoxPtr(), BoxInt(12)], FakeArrayDescr())
+ [boxptr(), boxint(12)], FakeArrayDescr())
assert resop.intval == 13
# ints
@@ -197,7 +204,6 @@
yield opnum, [x, y], z
def _int_comparison_operations():
- cpu = FakeCPU()
random_numbers = [-sys.maxint-1, -1, 0, 1, sys.maxint]
def pick():
r = random.randrange(-99999, 100000)
@@ -205,7 +211,6 @@
return r
else:
return random_numbers[r % len(random_numbers)]
- minint = -sys.maxint-1
for opnum, operation in [
(rop.INT_LT, lambda x, y: x < y),
(rop.INT_LE, lambda x, y: x <= y),
@@ -243,13 +248,13 @@
list(_int_binary_operations()) +
list(_int_comparison_operations()) +
list(_int_unary_operations())):
- yield opnum, [BoxInt(x) for x in args], retvalue
+ yield opnum, [boxint(x) for x in args], retvalue
if len(args) > 1:
assert len(args) == 2
- yield opnum, [BoxInt(args[0]), ConstInt(args[1])], retvalue
- yield opnum, [ConstInt(args[0]), BoxInt(args[1])], retvalue
+ yield opnum, [boxint(args[0]), ConstInt(args[1])], retvalue
+ yield opnum, [ConstInt(args[0]), boxint(args[1])], retvalue
if args[0] == args[1]:
- commonbox = BoxInt(args[0])
+ commonbox = boxint(args[0])
yield opnum, [commonbox, commonbox], retvalue
@@ -311,7 +316,7 @@
if isinstance(x, float):
boxargs.append(boxfloat(x))
else:
- boxargs.append(BoxInt(x))
+ boxargs.append(boxint(x))
yield opnum, boxargs, rettype, retvalue
if len(args) > 1:
assert len(args) == 2
diff --git a/pypy/jit/tool/oparser.py b/pypy/jit/tool/oparser.py
--- a/pypy/jit/tool/oparser.py
+++ b/pypy/jit/tool/oparser.py
@@ -14,59 +14,6 @@
class ParseError(Exception):
pass
-class ESCAPE_OP(N_aryOp, ResOpNone, ResOpWithDescr):
-
- OPNUM = -123
-
- def __init__(self, opnum, args, result, descr=None):
- assert opnum == self.OPNUM
- self.result = result
- self._args = args
- self.setdescr(descr)
-
- @classmethod
- def getopnum(cls):
- return cls.OPNUM
-
- def copy_if_modified_by_optimization(self, opt):
- newargs = None
- for i, arg in enumerate(self._args):
- new_arg = opt.get_value_replacement(arg)
- if new_arg is not None:
- if newargs is None:
- newargs = []
- for k in range(i):
- newargs.append(self._args[k])
- self._args[:i]
- newargs.append(new_arg)
- elif newargs is not None:
- newargs.append(arg)
- if newargs is None:
- return self
- return ESCAPE_OP(self.OPNUM, newargs, self.getresult(),
- self.getdescr())
-
-class FORCE_SPILL(UnaryOp, ResOpNone, PlainResOp):
-
- OPNUM = -124
-
- def __init__(self, opnum, args, result=None, descr=None):
- assert result is None
- assert descr is None
- assert opnum == self.OPNUM
- self.result = result
- self.initarglist(args)
-
- def getopnum(self):
- return self.OPNUM
-
- def clone(self):
- return FORCE_SPILL(self.OPNUM, self.getarglist()[:])
-
- def copy_and_change(self, opnum, args, result, descr):
- return FORCE_SPILL(opnum, args, result, descr)
-
-
class OpParser(object):
use_mock_model = False
@@ -231,12 +178,7 @@
try:
opnum = getattr(rop_lowercase, opname)
except AttributeError:
- if opname == 'escape':
- opnum = ESCAPE_OP.OPNUM
- elif opname == 'force_spill':
- opnum = FORCE_SPILL.OPNUM
- else:
- raise ParseError("unknown op: %s" % opname)
+ raise ParseError("unknown op: %s" % opname)
endnum = line.rfind(')')
if endnum == -1:
raise ParseError("invalid line: %s" % line)
@@ -276,16 +218,11 @@
return opnum, args, descr, fail_args
def create_op(self, opnum, result, args, descr):
- if opnum == ESCAPE_OP.OPNUM:
- return ESCAPE_OP(opnum, args, result, descr)
- if opnum == FORCE_SPILL.OPNUM:
- return FORCE_SPILL(opnum, args, result, descr)
- else:
- r = create_resop_dispatch(opnum, result, args,
- mutable=self.guards_with_failargs)
- if descr is not None:
- r.setdescr(descr)
- return r
+ r = create_resop_dispatch(opnum, result, args,
+ mutable=self.guards_with_failargs)
+ if descr is not None:
+ r.setdescr(descr)
+ return r
def parse_result_op(self, line, num):
res, op = line.split("=", 1)
diff --git a/pypy/jit/tool/test/test_oparser.py b/pypy/jit/tool/test/test_oparser.py
--- a/pypy/jit/tool/test/test_oparser.py
+++ b/pypy/jit/tool/test/test_oparser.py
@@ -24,7 +24,7 @@
# a comment
i2 = int_add(i0, i1)
i3 = int_sub(i2, 3) # another comment
- finish() [] # (tricky)
+ finish() # (tricky)
"""
loop = self.parse(x)
assert len(loop.operations) == 3
@@ -40,7 +40,7 @@
[p0]
finish(descr=f) [p0]
"""
- loop = self.parse(x, None, {'f': d})
+ loop = self.parse(x, None, {'f': d}, guards_with_failargs=True)
assert loop.operations[0].getdescr() is d
assert loop.operations[0].getfailargs() == loop.inputargs
@@ -90,7 +90,7 @@
def test_getvar_const_ptr(self):
x = '''
[]
- call_n(ConstPtr(func_ptr))
+ call_v(ConstPtr(func_ptr))
'''
TP = lltype.GcArray(lltype.Signed)
NULL = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.nullptr(TP))
@@ -163,7 +163,7 @@
def test_attach_comment_to_loop(self):
loop = self.parse(self.example_loop_log, guards_with_failargs=True)
assert loop.comment == ' # bridge out of Guard12, 6 ops'
- assert loop.operations[-3].get_failargs()
+ assert loop.operations[-3].getfailargs()
def test_parse_new_with_comma(self):
# this is generated by PYPYJITLOG, check that we can handle it
More information about the pypy-commit
mailing list