def test_finish_with_guard_not_forced_2_ref(self): cpu = self.cpu loop = self.parse(""" [p0, p1] guard_not_forced_2(descr=faildescr) [p1] finish(p0, descr=finaldescr) """, namespace={ 'faildescr': BasicFailDescr(1), 'finaldescr': BasicFinalDescr(2) }) token = JitCellToken() cpu.gc_ll_descr.init_nursery(100) cpu.setup_once() cpu.compile_loop(loop.inputargs, loop.operations, token) n = lltype.nullptr(llmemory.GCREF.TO) frame = lltype.cast_opaque_ptr(JITFRAMEPTR, cpu.execute_token(token, n, n)) assert getmap(frame).count('1') == 2
def optimize(self, ops): loop = self.parse(ops) self.add_guard_future_condition(loop) operations = loop.operations jumpop = operations[-1] assert jumpop.getopnum() == rop.JUMP inputargs = loop.inputargs jump_args = jumpop.getarglist()[:] operations = operations[:-1] preamble = TreeLoop('preamble') token = JitCellToken() trace = oparser.convert_loop_to_trace( loop, FakeMetaInterpStaticData(self.cpu)) compile_data = LoopCompileData(trace, inputargs) start_state, newops = self._do_optimize_loop(compile_data) preamble.operations = newops preamble.inputargs = start_state.renamed_inputargs return start_state, loop, preamble
def test_int_add(self): # random seed: 1202 # block length: 4 # AssertionError: Got 1431655764, expected 357913940 for value #3 faildescr1 = BasicFailDescr(1) faildescr2 = BasicFailDescr(2) v1 = BoxInt() v2 = BoxInt() v3 = BoxInt() v4 = BoxInt() v5 = BoxInt() v6 = BoxInt() v7 = BoxInt() v8 = BoxInt() v9 = BoxInt() v10 = BoxInt() v11 = BoxInt() tmp12 = BoxInt() cpu = CPU(None, None) cpu.setup_once() inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10] operations = [ ResOperation(rop.INT_ADD, [ConstInt(-1073741825), v3], v11), ResOperation(rop.INT_IS_TRUE, [v1], tmp12), ResOperation(rop.GUARD_FALSE, [tmp12], None, descr=faildescr1), ResOperation(rop.GUARD_FALSE, [v1], None, descr=faildescr2), ] operations[2].setfailargs([v10, v3, v6, v11, v9, v2]) operations[-1].setfailargs([v8, v2, v10, v6, v7, v9, v5, v4]) looptoken = JitCellToken() cpu.compile_loop(inputargs, operations, looptoken) args = [3 , -5 , 1431655765 , 47 , 12 , 1789569706 , 15 , 939524096 , 16 , -43] deadframe = cpu.execute_token(looptoken, *args) assert cpu.get_latest_descr(deadframe).identifier == 1 assert cpu.get_int_value(deadframe, 0) == -43 assert cpu.get_int_value(deadframe, 1) == 1431655765 assert cpu.get_int_value(deadframe, 2) == 1789569706 assert cpu.get_int_value(deadframe, 3) == 357913940 assert cpu.get_int_value(deadframe, 4) == 16 assert cpu.get_int_value(deadframe, 5) == -5
def parse_loop(self, ops, add_label=True): loop = self.parse(ops) loop.operations = filter(lambda op: op.getopnum() != rop.DEBUG_MERGE_POINT, loop.operations) token = JitCellToken() if add_label: label = ResOperation(rop.LABEL, loop.inputargs, descr=TargetToken(token)) else: label = loop.operations[0] label.setdescr(TargetToken(token)) jump = loop.operations[-1] loop = VectorLoop(label, loop.operations[0:-1], jump) loop.jump.setdescr(token) class Optimizer(object): metainterp_sd = FakeMetaInterpStaticData(self.cpu) jitdriver_sd = FakeJitDriverStaticData() opt = Optimizer() opt.jitdriver_sd.vec = True for op in loop.operations: if op.is_guard() and not op.getdescr(): descr = invent_fail_descr_for_op(op.getopnum(), opt) op.setdescr(descr) return loop
def test_ops_offset(self): from rpython.rlib import debug looptoken = JitCellToken() targettoken = TargetToken() loop = parse(""" [i0] label(i0, descr=targettoken) i1 = int_add(i0, 1) i2 = int_le(i1, 9) jump(i1, descr=targettoken) """, namespace=locals()) debug._log = dlog = debug.DebugLog() info = self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) ops_offset = info.ops_offset debug._log = None # assert ops_offset is looptoken._x86_ops_offset # 2*increment_debug_counter + ops + None assert len(ops_offset) == 2 + len(loop.operations) + 1 assert (ops_offset[loop.operations[0]] <= ops_offset[loop.operations[1]] <= ops_offset[loop.operations[2]] <= ops_offset[None])
def test_double_evenodd_pair(self): code = """ [i0] i1 = int_floordiv(i0, 2) i2 = int_floordiv(i0, 3) i3 = int_floordiv(i0, 4) i4 = int_floordiv(i0, 5) i5 = int_floordiv(i0, 6) i6 = int_floordiv(i0, 7) i7 = int_floordiv(i0, 8) i8 = int_le(i1, 0) guard_true(i8) [i1,i2,i3,i4,i5,i6,i7] finish(i0, descr=faildescr) """ # the guard forces 3 spills because after 4 divisions # all even slots of the managed registers are full loop = parse(code, namespace={'faildescr': BasicFinalDescr(1)}) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, 100) fail = self.cpu.get_latest_descr(deadframe) for i in range(2, 9): assert self.cpu.get_int_value(deadframe, i - 2) == 100 // i
def test_bug_rshift(): v1 = BoxInt() v2 = BoxInt() v3 = BoxInt() v4 = BoxInt() zero = BoxInt() inputargs = [v1] operations = [ ResOperation(rop.INT_ADD, [v1, v1], v2), ResOperation(rop.INT_INVERT, [v2], v3), ResOperation(rop.UINT_RSHIFT, [v1, ConstInt(3)], v4), ResOperation(rop.SAME_AS, [ConstInt(0)], zero), ResOperation(rop.GUARD_TRUE, [zero], None, descr=BasicFailDescr()), ResOperation(rop.FINISH, [], None, descr=BasicFinalDescr()) ] operations[-2].setfailargs([v4, v3]) cpu = CPU(None, None) cpu.setup_once() looptoken = JitCellToken() cpu.compile_loop(inputargs, operations, looptoken) deadframe = cpu.execute_token(looptoken, 9) assert cpu.get_int_value(deadframe, 0) == (9 >> 3) assert cpu.get_int_value(deadframe, 1) == (~18)
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 = InputArgInt() for op in allops: for guard in guards: if op == rop.INT_IS_TRUE: bp = InputArgInt(1) n = InputArgInt(0) else: bp = InputArgRef(p) n = InputArgRef(nullptr) for b in (bp, n): i1 = ResOperation(rop.SAME_AS_I, [ConstInt(1)]) f = ResOperation(op, [b]) ops = [ i1, f, ResOperation(guard, [f], descr=BasicFailDescr()), ResOperation(rop.FINISH, [ConstInt(0)], descr=BasicFinalDescr()), ] ops[-2].setfailargs([i1]) looptoken = JitCellToken() self.cpu.compile_loop([b], ops, looptoken) deadframe = self.cpu.execute_token(looptoken, b.getint()) result = self.cpu.get_int_value(deadframe, 0) if guard == rop.GUARD_FALSE: assert result == execute(self.cpu, None, op, None, b) else: assert result != execute(self.cpu, None, op, None, b)
def test_return_spilled_args(self): numargs = 50 ops = [] arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)]) ops.append(arglist) # spill every inputarg for i in range(numargs): ops.append("force_spill(i%d)\n" % i) ops.append("guard_value(i0, -1) %s" % arglist) ops = "".join(ops) loop = parse(ops) looptoken = JitCellToken() faildescr = loop.operations[-1].getdescr() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) ARGS = [lltype.Signed] * numargs RES = lltype.Signed args = [i + 1 for i in range(numargs)] deadframe = self.cpu.execute_token(looptoken, *args) fail = self.cpu.get_latest_descr(deadframe) assert fail is faildescr for i in range(numargs): assert self.cpu.get_int_value(deadframe, i) == i + 1 bridgeops = [arglist] bridgeops.append("guard_value(i1, -5) %s" % arglist) bridgeops = "".join(bridgeops) bridge = parse(bridgeops) faildescr2 = bridge.operations[-1].getdescr() self.cpu.compile_bridge(faildescr, bridge.inputargs, bridge.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, *args) fail = self.cpu.get_latest_descr(deadframe) assert fail is faildescr2 for i in range(numargs): assert self.cpu.get_int_value(deadframe, i) == i + 1
def test0(self): faildescr1 = BasicFailDescr(1) faildescr2 = BasicFailDescr(2) v1 = BoxInt() v2 = BoxInt() v3 = BoxInt() v4 = BoxInt() v5 = BoxInt() v6 = BoxInt() v7 = BoxInt() v8 = BoxInt() v9 = BoxInt() v10 = BoxInt() v11 = BoxInt() v12 = BoxInt() cpu = CPU(None, None) cpu.setup_once() inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10] operations = [ ResOperation(rop.INT_SUB, [ConstInt(-1073741824), v7], v11), ResOperation(rop.INT_GE, [v3, ConstInt(23)], v12), ResOperation(rop.GUARD_TRUE, [v12], None, descr=faildescr1), ResOperation(rop.GUARD_FALSE, [v1], None, descr=faildescr2), ] looptoken = JitCellToken() operations[2].setfailargs([v12, v8, v3, v2, v1, v11]) operations[3].setfailargs([v9, v6, v10, v2, v8, v5, v1, v4]) cpu.compile_loop(inputargs, operations, looptoken) args = [-12 , -26 , -19 , 7 , -5 , -24 , -37 , 62 , 9 , 12] deadframe = cpu.execute_token(looptoken, *args) assert cpu.get_int_value(deadframe, 0) == 0 assert cpu.get_int_value(deadframe, 1) == 62 assert cpu.get_int_value(deadframe, 2) == -19 assert cpu.get_int_value(deadframe, 3) == -26 assert cpu.get_int_value(deadframe, 4) == -12 assert cpu.get_int_value(deadframe, 5) == -1073741787
def test_ops_offset(self): from rpython.rlib import debug i0 = BoxInt() i1 = BoxInt() i2 = BoxInt() looptoken = JitCellToken() targettoken = TargetToken() operations = [ ResOperation(rop.LABEL, [i0], None, descr=targettoken), ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1), ResOperation(rop.INT_LE, [i1, ConstInt(9)], i2), ResOperation(rop.JUMP, [i1], None, descr=targettoken), ] inputargs = [i0] debug._log = dlog = debug.DebugLog() info = self.cpu.compile_loop(inputargs, operations, looptoken) ops_offset = info.ops_offset debug._log = None # assert ops_offset is looptoken._x86_ops_offset # 2*increment_debug_counter + ops + None assert len(ops_offset) == 2 + len(operations) + 1 assert (ops_offset[operations[0]] <= ops_offset[operations[1]] <= ops_offset[operations[2]] <= ops_offset[None])
def test_bug_int_is_true_1(): v1 = BoxInt() v2 = BoxInt() v3 = BoxInt() v4 = BoxInt() tmp5 = BoxInt() inputargs = [v1] operations = [ ResOperation(rop.INT_MUL, [v1, v1], v2), ResOperation(rop.INT_MUL, [v2, v1], v3), ResOperation(rop.INT_IS_TRUE, [v2], tmp5), ResOperation(rop.INT_IS_ZERO, [tmp5], v4), ResOperation(rop.GUARD_FALSE, [v1], None, descr=BasicFailDescr()), ResOperation(rop.FINISH, [], None, descr=BasicFinalDescr()), ] operations[-2].setfailargs([v4, v3, tmp5]) cpu = CPU(None, None) cpu.setup_once() looptoken = JitCellToken() cpu.compile_loop(inputargs, operations, looptoken) deadframe = cpu.execute_token(looptoken, -10) assert cpu.get_int_value(deadframe, 0) == 0 assert cpu.get_int_value(deadframe, 1) == -1000 assert cpu.get_int_value(deadframe, 2) == 1
def optimize_bridge(self, loops, bridge, expected, expected_target='Loop', **boxvalues): if isinstance(loops, str): loops = (loops, ) loops = [self.parse(loop) for loop in loops] bridge = self.parse(bridge) for loop in loops: loop.preamble = self.unroll_and_optimize(loop) preamble = loops[0].preamble token = JitCellToken() token.target_tokens = [l.operations[0].getdescr() for l in [preamble] + loops] boxes = {} for b in bridge.inputargs + [op.result for op in bridge.operations]: boxes[str(b)] = b for b, v in boxvalues.items(): boxes[b].value = v bridge.operations[-1].setdescr(token) self._do_optimize_bridge(bridge, None) if bridge.operations[-1].getopnum() == rop.LABEL: assert expected == 'RETRACE' return print '\n'.join([str(o) for o in bridge.operations]) expected = self.parse(expected) self.assert_equal(bridge, expected) if expected_target == 'Preamble': assert bridge.operations[-1].getdescr() is preamble.operations[0].getdescr() elif expected_target == 'Loop': assert len(loops) == 1 assert bridge.operations[-1].getdescr() is loops[0].operations[0].getdescr() elif expected_target.startswith('Loop'): n = int(expected_target[4:]) assert bridge.operations[-1].getdescr() is loops[n].operations[0].getdescr() else: assert False
def build_random_loop(self, cpu, builder_factory, r, startvars, allow_delay): loop = TreeLoop('test_random_function') loop.inputargs = startvars[:] loop.operations = [] loop._jitcelltoken = JitCellToken() builder = builder_factory(cpu, loop, startvars[:]) if allow_delay: needs_a_label = True else: self.insert_label(loop, 0, r) needs_a_label = False self.generate_ops(builder, r, loop, startvars, needs_a_label=needs_a_label) self.builder = builder self.loop = loop dump(loop) cpu.compile_loop(loop.inputargs, loop.operations, loop._jitcelltoken) if self.output: builder.print_loop(self.output)
def test_compile_bridge_check_profile_info(self): py.test.skip("does not work, reinvestigate") class FakeProfileAgent(object): def __init__(self): self.functions = [] def native_code_written(self, name, address, size): self.functions.append((name, address, size)) self.cpu.profile_agent = agent = FakeProfileAgent() i0 = InputArgInt() i1 = InputArgInt() i2 = InputArgInt() targettoken = TargetToken() faildescr1 = BasicFailDescr(1) faildescr2 = BasicFailDescr(2) looptoken = JitCellToken() looptoken.number = 17 class FakeString(object): def __init__(self, val): self.val = val def _get_str(self): return self.val operations = [ ResOperation(rop.LABEL, [i0], None, descr=targettoken), ResOperation(rop.DEBUG_MERGE_POINT, [FakeString("hello"), 0, 0], None), ResOperation(rop.INT_ADD, [i0, ConstInt(1)], i1), ResOperation(rop.INT_LE, [i1, ConstInt(9)], i2), ResOperation(rop.GUARD_TRUE, [i2], None, descr=faildescr1), ResOperation(rop.JUMP, [i1], None, descr=targettoken), ] inputargs = [i0] operations[-2].setfailargs([i1]) self.cpu.compile_loop(inputargs, operations, looptoken) name, loopaddress, loopsize = agent.functions[0] assert name == "Loop # 17: hello (loop counter 0)" assert loopaddress <= looptoken._ll_loop_code assert loopsize >= 40 # randomish number i1b = InputArgInt() i3 = InputArgInt() bridge = [ ResOperation(rop.INT_LE, [i1b, ConstInt(19)], i3), ResOperation(rop.GUARD_TRUE, [i3], None, descr=faildescr2), ResOperation(rop.DEBUG_MERGE_POINT, [FakeString("bye"), 0, 0], None), ResOperation(rop.JUMP, [i1b], None, descr=targettoken), ] bridge[1].setfailargs([i1b]) self.cpu.compile_bridge(faildescr1, [i1b], bridge, looptoken) name, address, size = agent.functions[1] assert name == "Bridge # 0: bye (loop counter 1)" # Would be exactly ==, but there are some guard failure recovery # stubs in-between assert address >= loopaddress + loopsize assert size >= 10 # randomish number deadframe = self.cpu.execute_token(looptoken, 2) fail = self.cpu.get_latest_descr(deadframe) assert fail.identifier == 2 res = self.cpu.get_int_value(deadframe, 0) assert res == 20
def setup_class(cls): if cls.runappdirect: py.test.skip("Can't run this test with -A") w_f = cls.space.appexec([], """(): def function(): pass return function """) cls.w_f = w_f ll_code = cast_instance_to_base_ptr(w_f.code) code_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, ll_code) logger = Logger(MockSD()) oplist = parse(""" [i1, i2, p2] i3 = int_add(i1, i2) debug_merge_point(0, 0, 0, 0, 0, ConstPtr(ptr0)) guard_nonnull(p2) [] guard_true(i3) [] """, namespace={ 'ptr0': code_gcref }).operations greenkey = [ConstInt(0), ConstInt(0), ConstPtr(code_gcref)] offset = {} for i, op in enumerate(oplist): if i != 1: offset[op] = i class FailDescr(BasicFailDescr): def get_jitcounter_hash(self): from rpython.rlib.rarithmetic import r_uint return r_uint(13) oplist[-1].setdescr(FailDescr()) oplist[-2].setdescr(FailDescr()) token = JitCellToken() token.number = 0 di_loop = JitDebugInfo(MockJitDriverSD, logger, token, oplist, 'loop', greenkey) di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist, 'loop', greenkey) di_loop.asminfo = AsmInfo(offset, 0x42, 12) di_bridge = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist, 'bridge', fail_descr=FailDescr()) di_bridge.asminfo = AsmInfo(offset, 0, 0) def interp_on_compile(): di_loop.oplist = cls.oplist pypy_hooks.after_compile(di_loop) def interp_on_compile_bridge(): pypy_hooks.after_compile_bridge(di_bridge) def interp_on_optimize(): di_loop_optimize.oplist = cls.oplist pypy_hooks.before_compile(di_loop_optimize) def interp_on_abort(): pypy_hooks.on_abort(Counters.ABORT_TOO_LONG, pypyjitdriver, greenkey, 'blah', Logger(MockSD), []) space = cls.space cls.w_on_compile = space.wrap(interp2app(interp_on_compile)) cls.w_on_compile_bridge = space.wrap( interp2app(interp_on_compile_bridge)) cls.w_on_abort = space.wrap(interp2app(interp_on_abort)) cls.w_int_add_num = space.wrap(rop.INT_ADD) cls.w_dmp_num = space.wrap(rop.DEBUG_MERGE_POINT) cls.w_on_optimize = space.wrap(interp2app(interp_on_optimize)) cls.orig_oplist = oplist cls.w_sorted_keys = space.wrap(sorted(Counters.counter_names))
def make_jitcell_token(jitdriver_sd): jitcell_token = JitCellToken() jitcell_token.outermost_jitdriver_sd = jitdriver_sd return jitcell_token
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 check_rewrite(self, frm_operations, to_operations, **namespace): # objects to use inside the test A = lltype.GcArray(lltype.Signed) adescr = get_array_descr(self.gc_ll_descr, A) adescr.tid = 4321 alendescr = adescr.lendescr # pinned_obj_type = lltype.GcStruct('PINNED_STRUCT', ('my_int', lltype.Signed)) pinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, pinned_obj_type, 'my_int') pinned_obj_ptr = lltype.malloc(pinned_obj_type) pinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, pinned_obj_ptr) assert rgc.pin(pinned_obj_gcref) # notpinned_obj_type = lltype.GcStruct('NOT_PINNED_STRUCT', ('my_int', lltype.Signed)) notpinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, notpinned_obj_type, 'my_int') notpinned_obj_ptr = lltype.malloc(notpinned_obj_type) notpinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, notpinned_obj_ptr) # ptr_array_descr = self.cpu.arraydescrof(MovableObjectTracker.ptr_array_type) # vtable_descr = self.gc_ll_descr.fielddescr_vtable O = lltype.GcStruct('O', ('parent', rclass.OBJECT), ('x', lltype.Signed)) o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True) register_known_gctype(self.cpu, o_vtable, O) # tiddescr = self.gc_ll_descr.fielddescr_tid wbdescr = self.gc_ll_descr.write_barrier_descr WORD = globals()['WORD'] # strdescr = self.gc_ll_descr.str_descr unicodedescr = self.gc_ll_descr.unicode_descr strlendescr = strdescr.lendescr unicodelendescr = unicodedescr.lendescr casmdescr = JitCellToken() clt = FakeLoopToken() clt._ll_initial_locs = [0, 8] frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw') clt.frame_info = frame_info frame_info.jfi_frame_depth = 13 frame_info.jfi_frame_size = 255 framedescrs = self.gc_ll_descr.getframedescrs(self.cpu) framelendescr = framedescrs.arraydescr.lendescr jfi_frame_depth = framedescrs.jfi_frame_depth jfi_frame_size = framedescrs.jfi_frame_size jf_frame_info = framedescrs.jf_frame_info signedframedescr = self.cpu.signedframedescr floatframedescr = self.cpu.floatframedescr casmdescr.compiled_loop_token = clt tzdescr = None # noone cares # namespace.update(locals()) # for funcname in self.gc_ll_descr._generated_functions: namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname) namespace[funcname + '_descr'] = getattr(self.gc_ll_descr, '%s_descr' % funcname) # ops = parse(frm_operations, namespace=namespace) operations = self.gc_ll_descr.rewrite_assembler(self.cpu, ops.operations, []) # make the array containing the GCREF's accessible inside the tests. # This must be done after we call 'rewrite_assembler'. Before that # call 'last_moving_obj_tracker' is None or filled with some old # value. namespace['ptr_array_gcref'] = self.gc_ll_descr.last_moving_obj_tracker.ptr_array_gcref expected = parse(to_operations % Evaluator(namespace), namespace=namespace) equaloplists(operations, expected.operations) lltype.free(frame_info, flavor='raw')
def check_rewrite(self, frm_operations, to_operations, **namespace): S = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed)) sdescr = get_size_descr(self.gc_ll_descr, S) sdescr.tid = 1234 # T = lltype.GcStruct('T', ('y', lltype.Signed), ('z', lltype.Ptr(S)), ('t', lltype.Signed)) tdescr = get_size_descr(self.gc_ll_descr, T) tdescr.tid = 5678 tzdescr = get_field_descr(self.gc_ll_descr, T, 'z') # A = lltype.GcArray(lltype.Signed) adescr = get_array_descr(self.gc_ll_descr, A) adescr.tid = 4321 alendescr = adescr.lendescr # B = lltype.GcArray(lltype.Char) bdescr = get_array_descr(self.gc_ll_descr, B) bdescr.tid = 8765 blendescr = bdescr.lendescr # C = lltype.GcArray(lltype.Ptr(S)) cdescr = get_array_descr(self.gc_ll_descr, C) cdescr.tid = 8111 clendescr = cdescr.lendescr # E = lltype.GcStruct('Empty') edescr = get_size_descr(self.gc_ll_descr, E) edescr.tid = 9000 # vtable_descr = self.gc_ll_descr.fielddescr_vtable O = lltype.GcStruct('O', ('parent', rclass.OBJECT), ('x', lltype.Signed)) o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True) register_known_gctype(self.cpu, o_vtable, O) # tiddescr = self.gc_ll_descr.fielddescr_tid wbdescr = self.gc_ll_descr.write_barrier_descr WORD = globals()['WORD'] # strdescr = self.gc_ll_descr.str_descr unicodedescr = self.gc_ll_descr.unicode_descr strlendescr = strdescr.lendescr unicodelendescr = unicodedescr.lendescr strhashdescr = self.gc_ll_descr.str_hash_descr unicodehashdescr = self.gc_ll_descr.unicode_hash_descr casmdescr = JitCellToken() clt = FakeLoopToken() clt._ll_initial_locs = [0, 8] frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw') clt.frame_info = frame_info frame_info.jfi_frame_depth = 13 frame_info.jfi_frame_size = 255 framedescrs = self.gc_ll_descr.getframedescrs(self.cpu) framelendescr = framedescrs.arraydescr.lendescr jfi_frame_depth = framedescrs.jfi_frame_depth jfi_frame_size = framedescrs.jfi_frame_size jf_frame_info = framedescrs.jf_frame_info jf_savedata = framedescrs.jf_savedata jf_force_descr = framedescrs.jf_force_descr jf_descr = framedescrs.jf_descr jf_guard_exc = framedescrs.jf_guard_exc jf_forward = framedescrs.jf_forward jf_extra_stack_depth = framedescrs.jf_extra_stack_depth signedframedescr = self.cpu.signedframedescr floatframedescr = self.cpu.floatframedescr casmdescr.compiled_loop_token = clt # guarddescr = AbstractFailDescr() # namespace.update(locals()) # for funcname in self.gc_ll_descr._generated_functions: namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname) namespace[funcname + '_descr'] = getattr(self.gc_ll_descr, '%s_descr' % funcname) # ops = parse(frm_operations, namespace=namespace) expected = parse(to_operations % Evaluator(namespace), namespace=namespace) operations = self.gc_ll_descr.rewrite_assembler( self.cpu, ops.operations, []) equaloplists(operations, expected.operations) lltype.free(frame_info, flavor='raw')
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() 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.GUARD_FALSE, [v1], None, descr=BasicFailDescr()), ] operations[-1].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) args = [-13, 10, 10, 8, -8, -16, -18, 46, -12, 26] deadframe = cpu.execute_token(looptoken, *args) 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_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() 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.GUARD_FALSE, [v1], None, descr=BasicFailDescr()), ] operations[-1].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) args = [17, -20, -6, 6, 1, 13, 13, 9, 49, 8] deadframe = cpu.execute_token(looptoken, *args) 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
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_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 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)
def test_wrong_guard3(self): # random seed: 8029 # block length: 10 faildescr1 = BasicFailDescr(1) faildescr2 = BasicFailDescr(2) faildescr3 = BasicFailDescr(3) faildescr4 = BasicFailDescr(4) 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() cpu = CPU(None, None) cpu.setup_once() inputargs = [v1, v2, v3, v4, v5, v6, v7, v8, v9, v10] operations = [ ResOperation(rop.UINT_LT, [ConstInt(-11), v7], v11), ResOperation(rop.INT_GE, [v3, v5], v12), ResOperation(rop.INT_INVERT, [v9], v13), ResOperation(rop.GUARD_VALUE, [v13, ConstInt(14)], None, descr=faildescr3), ResOperation(rop.INT_IS_ZERO, [v12], v14), ResOperation(rop.INT_SUB, [v2, v13], v15), ResOperation(rop.GUARD_VALUE, [v15, ConstInt(-32)], None, descr=faildescr4), ResOperation(rop.INT_FLOORDIV, [v3, ConstInt(805306366)], v16), ResOperation(rop.GUARD_VALUE, [v15, ConstInt(0)], None, descr=faildescr1), ResOperation(rop.GUARD_FALSE, [v1], None, descr=faildescr2), ] operations[3].setfailargs([]) operations[-4].setfailargs([v15]) operations[-2].setfailargs([v9, v4, v10, v11, v14]) operations[-1].setfailargs([v10, v8, v1, v6, v4]) looptoken = JitCellToken() cpu.compile_loop(inputargs, operations, looptoken) args = [ -39, -18, 1588243114, -9, -4, 1252698794, 0, 715827882, -15, 536870912 ] deadframe = cpu.execute_token(looptoken, *args) assert cpu.get_latest_descr(deadframe).identifier == 1 assert cpu.get_int_value(deadframe, 0) == -15 assert cpu.get_int_value(deadframe, 1) == -9 assert cpu.get_int_value(deadframe, 2) == 536870912 assert cpu.get_int_value(deadframe, 3) == 0 assert cpu.get_int_value(deadframe, 4) == 0