def test_nullity_with_guard(self):
allops = [rop.INT_IS_TRUE]
guards = [rop.GUARD_TRUE, rop.GUARD_FALSE]
p = lltype.cast_opaque_ptr(llmemory.GCREF,
lltype.malloc(lltype.GcStruct('x')))
nullptr = lltype.nullptr(llmemory.GCREF.TO)
f = BoxInt()
for op in allops:
for guard in guards:
if op == rop.INT_IS_TRUE:
bp = BoxInt(1)
n = BoxInt(0)
else:
bp = BoxPtr(p)
n = BoxPtr(nullptr)
for b in (bp, n):
i1 = BoxInt(1)
ops = [
ResOperation(rop.SAME_AS, [ConstInt(1)], i1),
ResOperation(op, [b], f),
ResOperation(guard, [f], None, descr=BasicFailDescr()),
ResOperation(rop.FINISH, [ConstInt(0)],
None,
descr=BasicFinalDescr()),
]
ops[-2].setfailargs([i1])
looptoken = JitCellToken()
self.cpu.compile_loop([b], ops, looptoken)
deadframe = self.cpu.execute_token(looptoken, b.value)
result = self.cpu.get_int_value(deadframe, 0)
if guard == rop.GUARD_FALSE:
assert result == execute(self.cpu, None, op, None,
b).value
else:
assert result != execute(self.cpu, None, op, None,
b).value
def test_calling_convention(self, monkeypatch):
if WORD != 4:
py.test.skip("32-bit only test")
from rpython.jit.backend.x86.regloc import eax, edx
from rpython.jit.backend.x86 import codebuf, callbuilder
from rpython.jit.codewriter.effectinfo import EffectInfo
from rpython.rlib.libffi import types, clibffi
had_stdcall = hasattr(clibffi, 'FFI_STDCALL')
if not had_stdcall: # not running on Windows, but we can still test
monkeypatch.setattr(clibffi, 'FFI_STDCALL', 12345, raising=False)
monkeypatch.setattr(callbuilder, 'stdcall_or_cdecl', True)
else:
assert callbuilder.stdcall_or_cdecl
#
for real_ffi, reported_ffi in [
(clibffi.FFI_DEFAULT_ABI, clibffi.FFI_DEFAULT_ABI),
(clibffi.FFI_STDCALL, clibffi.FFI_DEFAULT_ABI),
(clibffi.FFI_STDCALL, clibffi.FFI_STDCALL)
]:
cpu = self.cpu
mc = codebuf.MachineCodeBlockWrapper()
mc.MOV_rs(eax.value, 4) # argument 1
mc.MOV_rs(edx.value, 40) # argument 10
mc.SUB_rr(eax.value, edx.value) # return arg1 - arg10
if real_ffi == clibffi.FFI_DEFAULT_ABI:
mc.RET()
else:
mc.RET16_i(40)
rawstart = mc.materialize(cpu, [])
#
calldescr = cpu._calldescr_dynamic_for_tests([types.slong] * 10,
types.slong)
calldescr.get_call_conv = lambda: reported_ffi # <==== hack
# ^^^ we patch get_call_conv() so that the test also makes sense
# on Linux, because clibffi.get_call_conv() would always
# return FFI_DEFAULT_ABI on non-Windows platforms.
funcbox = ConstInt(rawstart)
i1 = InputArgInt()
i2 = InputArgInt()
c = ConstInt(-1)
faildescr = BasicFailDescr(1)
cz = ConstInt(0)
# we must call it repeatedly: if the stack pointer gets increased
# by 40 bytes by the STDCALL call, and if we don't expect it,
# then we are going to get our stack emptied unexpectedly by
# several repeated calls
ops = [
ResOperation(rop.CALL_RELEASE_GIL_I,
[cz, funcbox, i1, c, c, c, c, c, c, c, c, i2],
descr=calldescr),
ResOperation(rop.GUARD_NOT_FORCED, [], descr=faildescr),
ResOperation(rop.CALL_RELEASE_GIL_I,
[cz, funcbox, i1, c, c, c, c, c, c, c, c, i2],
descr=calldescr),
ResOperation(rop.GUARD_NOT_FORCED, [], descr=faildescr),
ResOperation(rop.CALL_RELEASE_GIL_I,
[cz, funcbox, i1, c, c, c, c, c, c, c, c, i2],
descr=calldescr),
ResOperation(rop.GUARD_NOT_FORCED, [], descr=faildescr),
ResOperation(rop.CALL_RELEASE_GIL_I,
[cz, funcbox, i1, c, c, c, c, c, c, c, c, i2],
descr=calldescr),
ResOperation(rop.GUARD_NOT_FORCED, [], descr=faildescr),
]
i3 = ops[0]
i4 = ops[2]
i5 = ops[4]
i6 = ops[6]
ops += [
ResOperation(rop.GUARD_FALSE, [i3], descr=BasicFailDescr(0)),
ResOperation(rop.FINISH, [], descr=BasicFinalDescr(1))
]
ops[-2].setfailargs([i3, i4, i5, i6])
ops[1].setfailargs([])
ops[3].setfailargs([])
ops[5].setfailargs([])
ops[7].setfailargs([])
looptoken = JitCellToken()
self.cpu.compile_loop([i1, i2], ops, looptoken)
deadframe = self.cpu.execute_token(looptoken, 123450, 123408)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 0
assert self.cpu.get_int_value(deadframe, 0) == 42
assert self.cpu.get_int_value(deadframe, 1) == 42
assert self.cpu.get_int_value(deadframe, 2) == 42
assert self.cpu.get_int_value(deadframe, 3) == 42
def test_shadowstack_call(self):
cpu = self.cpu
cpu.gc_ll_descr.init_nursery(100)
cpu.setup_once()
S = self.S
frames = []
def check(i):
assert cpu.gc_ll_descr.gcrootmap.curtop() == i
frame = rffi.cast(JITFRAMEPTR, i)
assert len(frame.jf_frame) == self.cpu.JITFRAME_FIXED_SIZE + 4
# we "collect"
frames.append(frame)
new_frame = JITFRAME.allocate(frame.jf_frame_info)
gcmap = unpack_gcmap(frame)
if self.cpu.backend_name.startswith('ppc64'):
assert gcmap == [30, 31, 32]
elif self.cpu.backend_name.startswith('zarch'):
# 10 gpr, 14 fpr -> 25 is the first slot
assert gcmap == [26, 27, 28]
elif self.cpu.IS_64_BIT:
assert gcmap == [28, 29, 30]
elif self.cpu.backend_name.startswith('arm'):
assert gcmap == [44, 45, 46]
else:
assert gcmap == [22, 23, 24]
for item, s in zip(gcmap, new_items):
new_frame.jf_frame[item] = rffi.cast(lltype.Signed, s)
assert cpu.gc_ll_descr.gcrootmap.curtop() == rffi.cast(lltype.Signed, frame)
cpu.gc_ll_descr.gcrootmap.settop(rffi.cast(lltype.Signed, new_frame))
print '"Collecting" moved the frame from %d to %d' % (
i, cpu.gc_ll_descr.gcrootmap.curtop())
frames.append(new_frame)
def check2(i):
assert cpu.gc_ll_descr.gcrootmap.curtop() == i
frame = rffi.cast(JITFRAMEPTR, i)
assert frame == frames[1]
assert frame != frames[0]
CHECK = lltype.FuncType([lltype.Signed], lltype.Void)
checkptr = llhelper(lltype.Ptr(CHECK), check)
check2ptr = llhelper(lltype.Ptr(CHECK), check2)
checkdescr = cpu.calldescrof(CHECK, CHECK.ARGS, CHECK.RESULT,
EffectInfo.MOST_GENERAL)
loop = self.parse("""
[p0, p1, p2]
pf = force_token() # this is the frame
call_n(ConstClass(check_adr), pf, descr=checkdescr) # this can collect
p3 = getfield_gc_r(p0, descr=fielddescr)
pf2 = force_token()
call_n(ConstClass(check2_adr), pf2, descr=checkdescr)
guard_nonnull(p3, descr=faildescr) [p0, p1, p2, p3]
p4 = getfield_gc_r(p0, descr=fielddescr)
finish(p4, descr=finaldescr)
""", namespace={'finaldescr': BasicFinalDescr(),
'faildescr': BasicFailDescr(),
'check_adr': checkptr, 'check2_adr': check2ptr,
'checkdescr': checkdescr,
'fielddescr': cpu.fielddescrof(S, 'x')})
token = JitCellToken()
cpu.compile_loop(loop.inputargs, loop.operations, token)
p0 = lltype.malloc(S, zero=True)
p1 = lltype.malloc(S)
p2 = lltype.malloc(S)
new_items = [lltype.malloc(S), lltype.malloc(S), lltype.malloc(S)]
new_items[0].x = new_items[2]
frame = cpu.execute_token(token, p0, p1, p2)
frame = lltype.cast_opaque_ptr(JITFRAMEPTR, frame)
gcmap = unpack_gcmap(lltype.cast_opaque_ptr(JITFRAMEPTR, frame))
assert len(gcmap) == 1
assert gcmap[0] < self.cpu.JITFRAME_FIXED_SIZE
item = rffi.cast(lltype.Ptr(S), frame.jf_frame[gcmap[0]])
assert item == new_items[2]
def test_call_alignment_call_assembler(self):
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
fdescr3 = BasicFinalDescr(3)
fdescr4 = BasicFinalDescr(4)
def assembler_helper(failindex, virtualizable):
assert 0, 'should not be called, but was with failindex (%d)' % failindex
return 13
FUNCPTR = lltype.Ptr(
lltype.FuncType([lltype.Signed, llmemory.GCREF], lltype.Signed))
class FakeJitDriverSD:
index_of_virtualizable = -1
_assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
assembler_helper_adr = llmemory.cast_ptr_to_adr(
_assembler_helper_ptr)
floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56]
ints = [7, 11, 23, 42, -42, 1111, 95, 1]
for case in range(256):
float_count = 0
int_count = 0
args = []
called_ops = ''
total_index = -1
for i in range(8):
if case & (1 << i):
args.append('f%d' % float_count)
else:
args.append('i%d' % int_count)
called_ops += 'f%d = cast_int_to_float(i%d)\n' % (
float_count, int_count)
int_count += 1
if total_index == -1:
total_index = float_count
float_count += 1
else:
called_ops += 'f%d = float_add(f%d, f%d)\n' % (
float_count + 1, total_index, float_count)
total_index = float_count + 1
float_count += 2
arguments = ', '.join(args)
called_ops = '[%s]\n' % arguments + called_ops
called_ops += 'finish(f%d, descr=fdescr3)\n' % total_index
# compile called loop
called_loop = parse(called_ops, namespace=locals())
called_looptoken = JitCellToken()
called_looptoken.outermost_jitdriver_sd = FakeJitDriverSD()
done_descr = called_loop.operations[-1].getdescr()
self.cpu.compile_loop(called_loop.inputargs,
called_loop.operations, called_looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
deadframe = cpu.execute_token(called_looptoken, *argvals)
assert cpu.get_latest_descr(deadframe) == fdescr3
t = longlong.getrealfloat(cpu.get_float_value(deadframe, 0))
assert abs(t - expected_result) < 0.0001
ARGS = []
RES = lltype.Float
for x in args:
if x[0] == 'f':
ARGS.append(lltype.Float)
else:
ARGS.append(lltype.Signed)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType(ARGS, RES)), ARGS, RES,
EffectInfo.MOST_GENERAL)
ops = '''
[%s]
f99 = call_assembler(%s, descr=called_looptoken)
guard_not_forced()[]
finish(f99, descr=fdescr4)
''' % (arguments, arguments)
loop = parse(ops, namespace=locals())
# we want to take the fast path
self.cpu.done_with_this_frame_descr_float = done_descr
try:
othertoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations,
othertoken)
# prepare call to called_loop
argvals, _ = self._prepare_args(args, floats, ints)
deadframe = cpu.execute_token(othertoken, *argvals)
x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0))
assert cpu.get_latest_descr(deadframe) == fdescr4
assert abs(x - expected_result) < 0.0001
finally:
del self.cpu.done_with_this_frame_descr_float
def run_guards_translated(gcremovetypeptr):
class A(object):
pass
class B(A):
pass
class C(B):
pass
def main(argv):
A()
B().foo = len(argv)
C()
return 0
t = TranslationContext()
t.config.translation.gc = "minimark"
t.config.translation.gcremovetypeptr = gcremovetypeptr
ann = t.buildannotator()
ann.build_types(main, [s_list_of_strings], main_entry_point=True)
rtyper = t.buildrtyper()
rtyper.specialize()
classdef = ann.bookkeeper.getuniqueclassdef(B)
rclass = getclassrepr(rtyper, classdef)
rinstance = getinstancerepr(rtyper, classdef)
LLB = rinstance.lowleveltype.TO
ptr_vtable_B = rclass.getvtable()
adr_vtable_B = llmemory.cast_ptr_to_adr(ptr_vtable_B)
vtable_B = llmemory.cast_adr_to_int(adr_vtable_B, mode="symbolic")
CPU = getcpuclass()
cpu = CPU(rtyper,
NoStats(),
translate_support_code=True,
gcdescr=get_description(t.config))
execute_token = cpu.make_execute_token(llmemory.GCREF)
finaldescr = BasicFinalDescr()
faildescr = BasicFailDescr()
descr_B = cpu.sizeof(LLB, ptr_vtable_B)
typeid_B = descr_B.get_type_id()
fielddescr_B = cpu.fielddescrof(LLB, 'inst_foo')
LLD = lltype.GcStruct('D', ('dd', lltype.Signed))
descr_D = cpu.sizeof(LLD)
fielddescr_D = cpu.fielddescrof(LLD, 'dd')
ARRAY = lltype.GcArray(lltype.Signed)
arraydescr = cpu.arraydescrof(ARRAY)
loop1 = parse("""
[p0]
guard_class(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""",
namespace={
'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B
})
loop1a = parse("""
[p0]
guard_nonnull_class(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""",
namespace={
'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B
})
loop2 = parse("""
[p0]
guard_gc_type(p0, ConstInt(typeid_B), descr=faildescr) []
finish(descr=finaldescr)
""",
namespace={
'finaldescr': finaldescr,
'faildescr': faildescr,
'typeid_B': typeid_B
})
loop3 = parse("""
[p0]
guard_is_object(p0, descr=faildescr) []
finish(descr=finaldescr)
""",
namespace={
'finaldescr': finaldescr,
'faildescr': faildescr
})
loop4 = parse("""
[p0]
guard_subclass(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""",
namespace={
'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B
})
def g():
cpu.setup_once()
token1 = JitCellToken()
token1a = JitCellToken()
token2 = JitCellToken()
token3 = JitCellToken()
token4 = JitCellToken()
cpu.compile_loop(loop1.inputargs, loop1.operations, token1)
cpu.compile_loop(loop1a.inputargs, loop1a.operations, token1a)
cpu.compile_loop(loop2.inputargs, loop2.operations, token2)
cpu.compile_loop(loop3.inputargs, loop3.operations, token3)
cpu.compile_loop(loop4.inputargs, loop4.operations, token4)
for token, p0 in [
(token1, rffi.cast(llmemory.GCREF, A())),
(token1, rffi.cast(llmemory.GCREF, B())),
(token1, rffi.cast(llmemory.GCREF, C())),
(token1a, rffi.cast(llmemory.GCREF, A())),
(token1a, lltype.nullptr(llmemory.GCREF.TO)),
(token1a, rffi.cast(llmemory.GCREF, B())),
(token1a, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, A())),
(token2, rffi.cast(llmemory.GCREF, B())),
(token2, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, [42, 43])),
(token3, rffi.cast(llmemory.GCREF, A())),
(token3, rffi.cast(llmemory.GCREF, B())),
(token3, rffi.cast(llmemory.GCREF, [44, 45])),
(token4, rffi.cast(llmemory.GCREF, A())),
(token4, rffi.cast(llmemory.GCREF, B())),
(token4, rffi.cast(llmemory.GCREF, C())),
]:
frame = execute_token(token, p0)
descr = cpu.get_latest_descr(frame)
if descr is finaldescr:
print 'match'
elif descr is faildescr:
print 'fail'
else:
print '???'
#
if token is token2: # guard_gc_type
print int(cpu.get_actual_typeid(p0) == typeid_B)
if token is token3: # guard_is_object
print int(cpu.check_is_object(p0))
for p0 in [
lltype.nullptr(llmemory.GCREF.TO),
rffi.cast(llmemory.GCREF, A()),
rffi.cast(llmemory.GCREF, B()),
rffi.cast(llmemory.GCREF, C()),
rffi.cast(llmemory.GCREF, lltype.malloc(LLD)),
rffi.cast(llmemory.GCREF, lltype.malloc(ARRAY, 5)),
rffi.cast(llmemory.GCREF, "foobar"),
rffi.cast(llmemory.GCREF, u"foobaz")
]:
results = ['B', 'D', 'A', 'S', 'U']
try:
cpu.protect_speculative_field(p0, fielddescr_B)
except SpeculativeError:
results[0] = '-'
try:
cpu.protect_speculative_field(p0, fielddescr_D)
except SpeculativeError:
results[1] = '-'
try:
cpu.protect_speculative_array(p0, arraydescr)
except SpeculativeError:
results[2] = '-'
try:
cpu.protect_speculative_string(p0)
except SpeculativeError:
results[3] = '-'
try:
cpu.protect_speculative_unicode(p0)
except SpeculativeError:
results[4] = '-'
print ''.join(results)
call_initial_function(t, g)
cbuilder = genc.CStandaloneBuilder(t, main, t.config)
cbuilder.generate_source(defines=cbuilder.DEBUG_DEFINES)
cbuilder.compile()
data = cbuilder.cmdexec('')
assert data == (
'fail\n'
'match\n'
'fail\n'
'fail\n'
'fail\n'
'match\n'
'fail\n'
'fail\n'
'0\n'
'match\n'
'1\n'
'fail\n'
'0\n'
'fail\n'
'0\n'
'match\n'
'1\n'
'match\n'
'1\n'
'fail\n'
'0\n'
'fail\n'
'match\n'
'match\n'
'-----\n' # null
'-----\n' # instance of A
'B----\n' # instance of B
'B----\n' # instance of C
'-D---\n'
'--A--\n'
'---S-\n'
'----U\n')
def run_unpack(self, unpack, vector_type, assignments, float=True):
vars = {'v': 0, 'f': 0, 'i': 0}
def newvar(type):
c = vars[type]
vars[type] = c + 1
if type == 'v':
return type + str(c) + vector_type
return type + str(c)
targettoken = TargetToken()
finaldescr = BasicFinalDescr(1)
args = []
args_values = []
pack = []
suffix = 'f' if float else 'i'
for var, vals in assignments.items():
v = newvar('v')
pack.append('%s = vec_%s()' % (v, suffix))
for i, val in enumerate(vals):
args_values.append(val)
f = newvar(suffix)
args.append(f)
count = 1
# create a new variable
vo = v
v = newvar('v')
pack.append('%s = vec_pack_%s(%s, %s, %d, %d)' % \
(v, suffix, vo, f, i, count))
vars['x'] = v
packs = '\n '.join(pack)
resvar = suffix + '{' + suffix + '}'
# format the resoperations, take care that the lhs of =
# is formated later with a new variable name
unpackops = unpack
if isinstance(unpack, str):
unpackops = [unpack]
unpacksf = []
for up in unpackops:
lhs, rhs = up.split("=")
rhsf = rhs.format(**vars)
newvar('i')
newvar('f')
newvar('v')
lhsf = lhs.format(**vars)
unpacksf.append(lhsf + '=' + rhsf)
unpacks = '\n '.join(unpacksf)
source = '''
[{args}]
label({args}, descr=targettoken)
{packs}
{unpacks}
finish({resvar}, descr=finaldescr)
'''.format(args=','.join(args),
packs=packs,
unpacks=unpacks,
resvar=resvar.format(**vars))
print(source)
return self._compile_and_run(source,
args_values,
float,
ns={
'targettoken': targettoken,
'finaldescr': finaldescr
})
class Storage(compile.ResumeGuardDescr):
"for tests."
def __init__(self, metainterp_sd=None, original_greenkey=None):
self.metainterp_sd = metainterp_sd
self.original_greenkey = original_greenkey
def store_final_boxes(self, op, boxes, metainterp_sd):
op.setfailargs(boxes)
def __eq__(self, other):
return True # screw this
#return type(self) is type(other) # xxx obscure
def _sortboxes(boxes):
_kind2count = {history.INT: 1, history.REF: 2, history.FLOAT: 3}
return sorted(boxes, key=lambda box: _kind2count[box.type])
final_descr = BasicFinalDescr()
class BaseTest(object):
def parse(self, s, boxkinds=None, want_fail_descr=True, postprocess=None):
self.oparse = OpParser(s, self.cpu, self.namespace, 'lltype',
boxkinds,
None, False, postprocess)
return self.oparse.parse()
def postprocess(self, op):
if op.is_guard():
op.rd_snapshot = resume.Snapshot(None, op.getfailargs())
op.rd_frame_info_list = resume.FrameInfo(None, "code", 11)
def add_guard_future_condition(self, res):
def test_bug_0():
v1 = BoxInt()
v2 = BoxInt()
v3 = BoxInt()
v4 = BoxInt()
v5 = BoxInt()
v6 = BoxInt()
v7 = BoxInt()
v8 = BoxInt()
v9 = BoxInt()
v10 = BoxInt()
v11 = BoxInt()
v12 = BoxInt()
v13 = BoxInt()
v14 = BoxInt()
v15 = BoxInt()
v16 = BoxInt()
v17 = BoxInt()
v18 = BoxInt()
v19 = BoxInt()
v20 = BoxInt()
v21 = BoxInt()
v22 = BoxInt()
v23 = BoxInt()
v24 = BoxInt()
v25 = BoxInt()
v26 = BoxInt()
v27 = BoxInt()
v28 = BoxInt()
v29 = BoxInt()
v30 = BoxInt()
v31 = BoxInt()
v32 = BoxInt()
v33 = BoxInt()
v34 = BoxInt()
v35 = BoxInt()
v36 = BoxInt()
v37 = BoxInt()
v38 = BoxInt()
v39 = BoxInt()
v40 = BoxInt()
zero = BoxInt()
tmp41 = BoxInt()
tmp42 = BoxInt()
tmp43 = BoxInt()
tmp44 = BoxInt()
tmp45 = BoxInt()
tmp46 = BoxInt()
inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10]
operations = [
ResOperation(rop.UINT_GT, [v3, ConstInt(-48)], v11),
ResOperation(rop.INT_XOR, [v8, v1], v12),
ResOperation(rop.INT_GT, [v6, ConstInt(-9)], v13),
ResOperation(rop.INT_LE, [v13, v2], v14),
ResOperation(rop.INT_LE, [v11, v5], v15),
ResOperation(rop.UINT_GE, [v13, v13], v16),
ResOperation(rop.INT_OR, [v9, ConstInt(-23)], v17),
ResOperation(rop.INT_LT, [v10, v13], v18),
ResOperation(rop.INT_OR, [v15, v5], v19),
ResOperation(rop.INT_XOR, [v17, ConstInt(54)], v20),
ResOperation(rop.INT_MUL, [v8, v10], v21),
ResOperation(rop.INT_OR, [v3, v9], v22),
ResOperation(rop.INT_AND, [v11, ConstInt(-4)], tmp41),
ResOperation(rop.INT_OR, [tmp41, ConstInt(1)], tmp42),
ResOperation(rop.INT_MOD, [v12, tmp42], v23),
ResOperation(rop.INT_IS_TRUE, [v6], v24),
ResOperation(rop.UINT_RSHIFT, [v15, ConstInt(6)], v25),
ResOperation(rop.INT_OR, [ConstInt(-4), v25], v26),
ResOperation(rop.INT_INVERT, [v8], v27),
ResOperation(rop.INT_SUB, [ConstInt(-113), v11], v28),
ResOperation(rop.INT_NEG, [v7], v29),
ResOperation(rop.INT_NEG, [v24], v30),
ResOperation(rop.INT_FLOORDIV, [v3, ConstInt(53)], v31),
ResOperation(rop.INT_MUL, [v28, v27], v32),
ResOperation(rop.INT_AND, [v18, ConstInt(-4)], tmp43),
ResOperation(rop.INT_OR, [tmp43, ConstInt(1)], tmp44),
ResOperation(rop.INT_MOD, [v26, tmp44], v33),
ResOperation(rop.INT_OR, [v27, v19], v34),
ResOperation(rop.UINT_LT, [v13, ConstInt(1)], v35),
ResOperation(rop.INT_AND, [v21, ConstInt(31)], tmp45),
ResOperation(rop.INT_RSHIFT, [v21, tmp45], v36),
ResOperation(rop.INT_AND, [v20, ConstInt(31)], tmp46),
ResOperation(rop.UINT_RSHIFT, [v4, tmp46], v37),
ResOperation(rop.UINT_GT, [v33, ConstInt(-11)], v38),
ResOperation(rop.INT_NEG, [v7], v39),
ResOperation(rop.INT_GT, [v24, v32], v40),
ResOperation(rop.SAME_AS, [ConstInt(0)], zero),
ResOperation(rop.GUARD_TRUE, [zero], None, descr=BasicFailDescr()),
ResOperation(rop.FINISH, [], None, descr=BasicFinalDescr())
]
operations[-2].setfailargs(
[v40, v36, v37, v31, v16, v34, v35, v23, v22, v29, v14, v39, v30, v38])
cpu = CPU(None, None)
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
deadframe = cpu.execute_token(looptoken, -13, 10, 10, 8, -8, -16, -18, 46,
-12, 26)
assert cpu.get_int_value(deadframe, 0) == 0
assert cpu.get_int_value(deadframe, 1) == 0
assert cpu.get_int_value(deadframe, 2) == 0
assert cpu.get_int_value(deadframe, 3) == 0
assert cpu.get_int_value(deadframe, 4) == 1
assert cpu.get_int_value(deadframe, 5) == -7
assert cpu.get_int_value(deadframe, 6) == 1
assert cpu.get_int_value(deadframe, 7) == 0
assert cpu.get_int_value(deadframe, 8) == -2
assert cpu.get_int_value(deadframe, 9) == 18
assert cpu.get_int_value(deadframe, 10) == 1
assert cpu.get_int_value(deadframe, 11) == 18
assert cpu.get_int_value(deadframe, 12) == -1
assert cpu.get_int_value(deadframe, 13) == 0
def test_bug_2():
cpu = CPU(None, None)
cpu.setup_once()
S4 = lltype.Struct('Sx', ("f0", lltype.Char), ("f1", lltype.Signed),
("f2", lltype.Signed), ("f3", lltype.Signed))
S5 = lltype.GcArray(S4)
v1 = BoxInt()
v2 = BoxInt()
v3 = BoxInt()
v4 = BoxInt()
v5 = BoxInt()
v6 = BoxInt()
v7 = BoxInt()
v8 = BoxInt()
v9 = BoxInt()
v10 = BoxInt()
tmp11 = BoxInt()
tmp12 = BoxPtr()
faildescr0 = BasicFailDescr()
tmp13 = BoxPtr()
faildescr1 = BasicFailDescr()
finishdescr2 = BasicFinalDescr()
const_ptr14 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.STR, 1)))
const_ptr15 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF,
lltype.malloc(rstr.UNICODE, 489)))
const_ptr16 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.UNICODE,
16)))
const_ptr17 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S5, 299)))
inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10]
xtp, func, funcdescr = getexception(cpu, 3)
xtp2, func2, func2descr = getexception(cpu, 2)
operations = [
ResOperation(rop.STRGETITEM, [const_ptr14, ConstInt(0)], tmp11),
ResOperation(rop.LABEL,
[v1, v2, tmp11, v3, v4, v5, v6, v7, v8, v9, v10], None,
TargetToken()),
ResOperation(rop.UNICODESETITEM,
[const_ptr15, v4, ConstInt(22)], None),
ResOperation(rop.CALL, [ConstInt(func), v2, v1, v9],
None,
descr=funcdescr),
ResOperation(rop.GUARD_EXCEPTION, [ConstInt(xtp)],
tmp12,
descr=faildescr0),
ResOperation(
rop.UNICODESETITEM,
[const_ptr16, ConstInt(13), ConstInt(9)], None),
ResOperation(rop.SETINTERIORFIELD_GC, [const_ptr17, v3, v7], None,
cpu.interiorfielddescrof(S5, 'f3')),
ResOperation(rop.CALL, [ConstInt(func2), v7, v10],
None,
descr=func2descr),
ResOperation(rop.GUARD_NO_EXCEPTION, [], tmp13, descr=faildescr1),
ResOperation(rop.FINISH, [], None, descr=finishdescr2),
]
operations[4].setfailargs([v4, v8, v10, v2, v9, v7, v6, v1])
operations[8].setfailargs([v3, v9, v2, v6, v4])
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
loop_args = [1, -39, 46, 21, 16, 6, -4611686018427387905, 12, 14, 2]
frame = cpu.execute_token(looptoken, *loop_args)
assert cpu.get_int_value(frame, 0) == 46
assert cpu.get_int_value(frame, 1) == 14
assert cpu.get_int_value(frame, 2) == -39
assert cpu.get_int_value(frame, 3) == 6
assert cpu.get_int_value(frame, 4) == 21
S4 = lltype.GcStruct('Sx', ("parent", rclass.OBJECT),
("f0", lltype.Signed))
S5 = lltype.GcStruct('Sx', ("f0", lltype.Signed))
S6 = lltype.GcArray(lltype.Signed)
S7 = lltype.GcStruct('Sx', ("parent", rclass.OBJECT), ("f0", lltype.Char))
S8 = lltype.Struct('Sx', ("f0", lltype.Char), ("f1", lltype.Signed),
("f2", lltype.Signed), ("f3", lltype.Signed))
S9 = lltype.GcArray(S8)
v1 = BoxInt()
v2 = BoxInt()
v3 = BoxInt()
v4 = BoxInt()
v5 = BoxInt()
v6 = BoxInt()
v7 = BoxInt()
v8 = BoxInt()
v9 = BoxInt()
v10 = BoxInt()
v11 = BoxInt()
v12 = BoxInt()
v13 = BoxInt()
v14 = BoxInt()
v15 = BoxInt()
v16 = BoxInt()
v17 = BoxInt()
v18 = BoxInt()
v19 = BoxInt()
p20 = BoxPtr()
tmp21 = BoxPtr()
faildescr3 = BasicFailDescr()
tmp22 = BoxPtr()
faildescr4 = BasicFailDescr()
tmp23 = BoxInt()
tmp24 = BoxInt()
tmp25 = BoxInt()
tmp26 = BoxInt()
tmp27 = BoxInt()
tmp28 = BoxInt()
tmp29 = BoxInt()
faildescr5 = BasicFailDescr()
tmp30 = BoxPtr()
faildescr6 = BasicFailDescr()
finishdescr7 = BasicFinalDescr()
const_ptr31 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S4)))
const_ptr32 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.STR, 46)))
const_ptr33 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S5)))
const_ptr34 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.UNICODE,
26)))
const_ptr35 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.UNICODE,
15)))
const_ptr36 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S7)))
const_ptr37 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.STR, 484)))
const_ptr38 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S9, 299)))
inputargs = [v1, v2, v3, v4, v5]
func3, func3descr = getnoexception(cpu, 5)
xtp3, func4, func4descr = getexception(cpu, 10)
operations = [
ResOperation(rop.GUARD_EXCEPTION, [ConstInt(xtp2)],
tmp21,
descr=faildescr3),
ResOperation(rop.INT_IS_ZERO, [v4], v6),
ResOperation(rop.INT_NE, [v6, ConstInt(13)], v7),
ResOperation(rop.GETFIELD_GC, [const_ptr31], v8,
cpu.fielddescrof(S4, 'f0')),
ResOperation(rop.STRSETITEM,
[const_ptr32, v6, ConstInt(0)], None),
ResOperation(rop.NEWSTR, [ConstInt(5)], tmp22),
ResOperation(rop.STRSETITEM,
[tmp22, ConstInt(0), ConstInt(42)], None),
ResOperation(rop.STRSETITEM,
[tmp22, ConstInt(1), ConstInt(42)], None),
ResOperation(rop.STRSETITEM,
[tmp22, ConstInt(2), ConstInt(20)], None),
ResOperation(rop.STRSETITEM,
[tmp22, ConstInt(3), ConstInt(48)], None),
ResOperation(rop.STRSETITEM,
[tmp22, ConstInt(4), ConstInt(6)], None),
ResOperation(rop.GETFIELD_GC, [const_ptr33], v9,
cpu.fielddescrof(S5, 'f0')),
ResOperation(rop.UNICODESETITEM,
[const_ptr34, ConstInt(24),
ConstInt(65533)], None),
ResOperation(rop.GETFIELD_GC, [const_ptr31], v10,
cpu.fielddescrof(S4, 'f0')),
ResOperation(rop.INT_NE, [v10, ConstInt(25)], v11),
ResOperation(rop.CALL, [ConstInt(func3), v5, v1, v8, v3, v2],
v12,
descr=func3descr),
ResOperation(rop.GUARD_NO_EXCEPTION, [], None, descr=faildescr4),
ResOperation(rop.UNICODELEN, [const_ptr35], tmp23),
ResOperation(rop.NEW_ARRAY, [v2], p20, cpu.arraydescrof(S6)),
ResOperation(rop.GETFIELD_GC, [const_ptr36], v13,
cpu.fielddescrof(S7, 'f0')),
ResOperation(rop.INT_OR, [v8, ConstInt(2)], tmp24),
ResOperation(rop.INT_FLOORDIV, [ConstInt(8), tmp24], v14),
ResOperation(rop.GETARRAYITEM_GC, [p20, ConstInt(3)], v15,
cpu.arraydescrof(S6)),
ResOperation(
rop.COPYSTRCONTENT,
[tmp22, const_ptr37,
ConstInt(1),
ConstInt(163),
ConstInt(0)], None),
ResOperation(rop.COPYUNICODECONTENT,
[const_ptr35, const_ptr34,
ConstInt(13),
ConstInt(0), v6], None),
ResOperation(rop.STRGETITEM, [tmp22, v6], tmp25),
ResOperation(rop.STRGETITEM, [tmp22, ConstInt(0)], tmp26),
ResOperation(rop.GETINTERIORFIELD_GC, [const_ptr38, v13], v16,
cpu.interiorfielddescrof(S9, 'f0')),
ResOperation(rop.INT_GE, [v4, v5], v17),
ResOperation(rop.INT_OR, [v13, ConstInt(2)], tmp27),
ResOperation(rop.INT_FLOORDIV, [ConstInt(12), tmp27], v18),
ResOperation(rop.INT_AND, [v1, ConstInt(-4)], tmp28),
ResOperation(rop.INT_OR, [tmp28, ConstInt(2)], tmp29),
ResOperation(rop.INT_FLOORDIV, [v15, tmp29], v19),
ResOperation(rop.GUARD_FALSE, [v17], None, descr=faildescr5),
ResOperation(rop.UNICODESETITEM,
[const_ptr34, ConstInt(20),
ConstInt(65522)], None),
ResOperation(
rop.CALL,
[ConstInt(func4), v3, v9, v10, v8, v11, v5, v13, v14, v15, v6],
None,
descr=func4descr),
ResOperation(rop.GUARD_NO_EXCEPTION, [], tmp30, descr=faildescr6),
ResOperation(rop.FINISH, [], None, descr=finishdescr7),
]
operations[0].setfailargs([])
operations[16].setfailargs([v5, v9])
operations[34].setfailargs([])
operations[37].setfailargs([v12, v19, v10, v7, v4, v8, v18, v15, v9])
cpu.compile_bridge(faildescr1, inputargs, operations, looptoken)
frame = cpu.execute_token(looptoken, *loop_args)
#assert cpu.get_int_value(frame, 0) == -9223372036854775766
assert cpu.get_int_value(frame, 1) == 0
#assert cpu.get_int_value(frame, 2) == -9223372036854775808
assert cpu.get_int_value(frame, 3) == 1
assert cpu.get_int_value(frame, 4) == 6
#assert cpu.get_int_value(frame, 5) == -9223372036854775808
assert cpu.get_int_value(frame, 6) == 0
assert cpu.get_int_value(frame, 7) == 0
#assert cpu.get_int_value(frame, 8) == 26
S4 = lltype.GcStruct('Sx', ("parent", rclass.OBJECT),
("f0", lltype.Signed), ("f1", lltype.Signed))
S5 = lltype.GcStruct('Sx', ("parent", rclass.OBJECT),
("f0", lltype.Signed))
S6 = lltype.GcStruct('Sx', ("f0", lltype.Signed), ("f1", rffi.UCHAR))
v1 = BoxInt()
v2 = BoxInt()
v3 = BoxInt()
v4 = BoxInt()
v5 = BoxInt()
v6 = BoxInt()
v7 = BoxInt()
v8 = BoxInt()
v9 = BoxInt()
v10 = BoxInt()
v11 = BoxInt()
v12 = BoxInt()
v13 = BoxInt()
v14 = BoxInt()
v15 = BoxInt()
v16 = BoxInt()
v17 = BoxInt()
v18 = BoxInt()
tmp19 = BoxPtr()
faildescr8 = BasicFailDescr()
tmp20 = BoxInt()
tmp21 = BoxInt()
tmp22 = BoxInt()
tmp23 = BoxInt()
faildescr9 = BasicFailDescr()
tmp24 = BoxInt()
tmp25 = BoxInt()
tmp26 = BoxInt()
tmp27 = BoxPtr()
tmp28 = BoxPtr()
faildescr10 = BasicFailDescr()
finishdescr11 = BasicFinalDescr()
const_ptr29 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S4)))
const_ptr30 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.UNICODE,
26)))
const_ptr31 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.UNICODE, 1)))
const_ptr32 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S5)))
const_ptr33 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S6)))
const_ptr34 = ConstPtr(
lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(rstr.STR, 26)))
inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9]
operations = [
ResOperation(rop.GUARD_EXCEPTION, [ConstInt(xtp3)],
tmp19,
descr=faildescr8),
ResOperation(rop.SETFIELD_GC, [const_ptr29, v7], None,
cpu.fielddescrof(S4, 'f0')),
ResOperation(rop.UNICODEGETITEM,
[const_ptr30, ConstInt(21)], tmp20),
ResOperation(rop.UNICODEGETITEM,
[const_ptr30, ConstInt(10)], tmp21),
ResOperation(rop.UINT_RSHIFT, [v9, ConstInt(40)], v10),
ResOperation(rop.UNICODEGETITEM,
[const_ptr30, ConstInt(25)], tmp22),
ResOperation(rop.INT_NE, [ConstInt(-8), v9], v11),
ResOperation(rop.INT_MUL_OVF, [v3, ConstInt(-4)], tmp23),
ResOperation(rop.GUARD_OVERFLOW, [], None, descr=faildescr9),
ResOperation(rop.UNICODESETITEM,
[const_ptr31, ConstInt(0),
ConstInt(50175)], None),
ResOperation(rop.UINT_GT, [v8, ConstInt(-6)], v12),
ResOperation(rop.GETFIELD_GC, [const_ptr32], v13,
cpu.fielddescrof(S5, 'f0')),
ResOperation(rop.INT_AND, [ConstInt(8), v8], v14),
ResOperation(rop.INT_INVERT, [v1], v15),
ResOperation(rop.SETFIELD_GC, [const_ptr33, ConstInt(3)], None,
cpu.fielddescrof(S6, 'f1')),
ResOperation(rop.INT_GE, [v14, v6], v16),
ResOperation(rop.INT_AND, [v5, ConstInt(-4)], tmp24),
ResOperation(rop.INT_OR, [tmp24, ConstInt(2)], tmp25),
ResOperation(rop.INT_FLOORDIV, [v9, tmp25], v17),
ResOperation(rop.STRLEN, [const_ptr34], tmp26),
ResOperation(rop.NEWSTR, [ConstInt(7)], tmp27),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(0), ConstInt(21)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(1), ConstInt(79)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(2), ConstInt(7)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(3), ConstInt(2)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(4), ConstInt(229)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(5), ConstInt(233)], None),
ResOperation(rop.STRSETITEM,
[tmp27, ConstInt(6), ConstInt(208)], None),
ResOperation(rop.INT_LT, [ConstInt(-31), v10], v18),
ResOperation(rop.SAME_AS,
[ConstPtr(lltype.nullptr(llmemory.GCREF.TO))], tmp28),
ResOperation(rop.GUARD_NONNULL_CLASS, [tmp28, ConstInt(xtp2)],
None,
descr=faildescr10),
ResOperation(rop.FINISH, [v4], None, descr=finishdescr11),
]
operations[0].setfailargs([])
operations[8].setfailargs([tmp23, v5, v3, v11, v6])
operations[30].setfailargs([v6])
cpu.compile_bridge(faildescr6, inputargs, operations, looptoken)
frame = cpu.execute_token(looptoken, *loop_args)
#assert cpu.get_int_value(frame, 0) == -9223372036854775808
v1 = BoxInt()
v2 = BoxInt()
p3 = BoxPtr()
tmp4 = BoxInt()
tmp5 = BoxPtr()
faildescr12 = BasicFailDescr()
finishdescr13 = BasicFinalDescr()
inputargs = [v1]
_, func5, func5descr = getexception(cpu, 0)
vt = getvtable(cpu, S4)
operations = [
ResOperation(rop.INT_AND, [v1, ConstInt(63)], tmp4),
ResOperation(rop.INT_LSHIFT, [ConstInt(10), tmp4], v2),
ResOperation(rop.NEW_WITH_VTABLE, [ConstInt(vt)], p3),
ResOperation(rop.CALL, [ConstInt(func5)], None, descr=func5descr),
ResOperation(rop.GUARD_EXCEPTION, [ConstInt(xtp2)],
tmp5,
descr=faildescr12),
ResOperation(rop.FINISH, [], None, descr=finishdescr13),
]
operations[4].setfailargs([v2])
cpu.compile_bridge(faildescr10, inputargs, operations, looptoken)
frame = cpu.execute_token(looptoken, *loop_args)
def test_bug_1():
v1 = BoxInt()
v2 = BoxInt()
v3 = BoxInt()
v4 = BoxInt()
v5 = BoxInt()
v6 = BoxInt()
v7 = BoxInt()
v8 = BoxInt()
v9 = BoxInt()
v10 = BoxInt()
v11 = BoxInt()
v12 = BoxInt()
v13 = BoxInt()
v14 = BoxInt()
v15 = BoxInt()
v16 = BoxInt()
v17 = BoxInt()
v18 = BoxInt()
v19 = BoxInt()
v20 = BoxInt()
v21 = BoxInt()
v22 = BoxInt()
v23 = BoxInt()
v24 = BoxInt()
v25 = BoxInt()
v26 = BoxInt()
v27 = BoxInt()
v28 = BoxInt()
v29 = BoxInt()
v30 = BoxInt()
v31 = BoxInt()
v32 = BoxInt()
v33 = BoxInt()
v34 = BoxInt()
v35 = BoxInt()
v36 = BoxInt()
v37 = BoxInt()
v38 = BoxInt()
v39 = BoxInt()
v40 = BoxInt()
zero = BoxInt()
tmp41 = BoxInt()
tmp42 = BoxInt()
tmp43 = BoxInt()
tmp44 = BoxInt()
tmp45 = BoxInt()
inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10]
operations = [
ResOperation(rop.UINT_LT, [v6, ConstInt(0)], v11),
ResOperation(rop.INT_AND, [v3, ConstInt(31)], tmp41),
ResOperation(rop.INT_RSHIFT, [v3, tmp41], v12),
ResOperation(rop.INT_NEG, [v2], v13),
ResOperation(rop.INT_ADD, [v11, v7], v14),
ResOperation(rop.INT_OR, [v3, v2], v15),
ResOperation(rop.INT_OR, [v12, v12], v16),
ResOperation(rop.INT_NE, [v2, v5], v17),
ResOperation(rop.INT_AND, [v5, ConstInt(31)], tmp42),
ResOperation(rop.UINT_RSHIFT, [v14, tmp42], v18),
ResOperation(rop.INT_AND, [v14, ConstInt(31)], tmp43),
ResOperation(rop.INT_LSHIFT, [ConstInt(7), tmp43], v19),
ResOperation(rop.INT_NEG, [v19], v20),
ResOperation(rop.INT_MOD, [v3, ConstInt(1)], v21),
ResOperation(rop.UINT_GE, [v15, v1], v22),
ResOperation(rop.INT_AND, [v16, ConstInt(31)], tmp44),
ResOperation(rop.INT_LSHIFT, [v8, tmp44], v23),
ResOperation(rop.INT_IS_TRUE, [v17], v24),
ResOperation(rop.INT_AND, [v5, ConstInt(31)], tmp45),
ResOperation(rop.INT_LSHIFT, [v14, tmp45], v25),
ResOperation(rop.INT_LSHIFT, [v5, ConstInt(17)], v26),
ResOperation(rop.INT_EQ, [v9, v15], v27),
ResOperation(rop.INT_GE, [ConstInt(0), v6], v28),
ResOperation(rop.INT_NEG, [v15], v29),
ResOperation(rop.INT_NEG, [v22], v30),
ResOperation(rop.INT_ADD, [v7, v16], v31),
ResOperation(rop.UINT_LT, [v19, v19], v32),
ResOperation(rop.INT_ADD, [v2, ConstInt(1)], v33),
ResOperation(rop.INT_NEG, [v5], v34),
ResOperation(rop.INT_ADD, [v17, v24], v35),
ResOperation(rop.UINT_LT, [ConstInt(2), v16], v36),
ResOperation(rop.INT_NEG, [v9], v37),
ResOperation(rop.INT_GT, [v4, v11], v38),
ResOperation(rop.INT_LT, [v27, v22], v39),
ResOperation(rop.INT_NEG, [v27], v40),
ResOperation(rop.SAME_AS, [ConstInt(0)], zero),
ResOperation(rop.GUARD_TRUE, [zero], None, descr=BasicFailDescr()),
ResOperation(rop.FINISH, [], None, descr=BasicFinalDescr())
]
operations[-2].setfailargs([
v40, v10, v36, v26, v13, v30, v21, v33, v18, v25, v31, v32, v28, v29,
v35, v38, v20, v39, v34, v23, v37
])
cpu = CPU(None, None)
cpu.setup_once()
looptoken = JitCellToken()
cpu.compile_loop(inputargs, operations, looptoken)
deadframe = cpu.execute_token(looptoken, 17, -20, -6, 6, 1, 13, 13, 9, 49,
8)
assert cpu.get_int_value(deadframe, 0) == 0
assert cpu.get_int_value(deadframe, 1) == 8
assert cpu.get_int_value(deadframe, 2) == 1
assert cpu.get_int_value(deadframe, 3) == 131072
assert cpu.get_int_value(deadframe, 4) == 20
assert cpu.get_int_value(deadframe, 5) == -1
assert cpu.get_int_value(deadframe, 6) == 0
assert cpu.get_int_value(deadframe, 7) == -19
assert cpu.get_int_value(deadframe, 8) == 6
assert cpu.get_int_value(deadframe, 9) == 26
assert cpu.get_int_value(deadframe, 10) == 12
assert cpu.get_int_value(deadframe, 11) == 0
assert cpu.get_int_value(deadframe, 12) == 0
assert cpu.get_int_value(deadframe, 13) == 2
assert cpu.get_int_value(deadframe, 14) == 2
assert cpu.get_int_value(deadframe, 15) == 1
assert cpu.get_int_value(deadframe, 16) == -57344
assert cpu.get_int_value(deadframe, 17) == 1
assert cpu.get_int_value(deadframe, 18) == -1
if WORD == 4:
assert cpu.get_int_value(deadframe, 19) == -2147483648
elif WORD == 8:
assert cpu.get_int_value(deadframe, 19) == 19327352832
assert cpu.get_int_value(deadframe, 20) == -49
