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