def test_evenodd_pair_extensive(self, value): instrs = [] failargs = [] values = [] j = 0 mapping = (('int_floordiv', lambda x, y: x // y), ('int_mod', lambda x, y: x % y), ('int_mul_ovf', lambda x, y: x * y)) for i in range(20): name, func = mapping[j] instrs.append("i{d} = {i}(i0, {d})".format(d=i + 1, i=name)) values.append((name, func(value, i + 1))) failargs.append("i" + str(i + 1)) j += 1 if j >= len(mapping): j = 0 code = """ [i0] {instrs} i99 = int_add(i0, 1) i100 = int_eq(i0,i99) guard_true(i100) [{failargs}] # will always fail!! finish(i0, descr=faildescr) """.format(instrs=('\n' + ' ' * 8).join(instrs), failargs=','.join(failargs)) # 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, value) fail = self.cpu.get_latest_descr(deadframe) for i, (name, v) in enumerate(values): assert self.cpu.get_int_value(deadframe, i) == v
def test_compile_more_than_32k(self): # the guard_true needs a "b.cond" jumping forward more than 32 kb looptoken = JitCellToken() targettoken = TargetToken() ops = [ '[i0]', 'label(i0, descr=targettoken)', 'i1 = int_le(i0, 9)', 'guard_true(i1, descr=faildescr) [i0]', ] NUM = 8193 iprevious = 'i0' for i in range(NUM): inext = 'i%d' % (i + 2,) ops.append('%s = int_add(%s, 1)' % (inext, iprevious)) iprevious = inext ops.append('jump(%s, descr=targettoken)' % (iprevious,)) loop = parse('\n'.join(ops), namespace={'targettoken': targettoken, 'faildescr': BasicFailDescr(5)}) self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, -42) fail = self.cpu.get_latest_descr(deadframe) assert fail.identifier == 5 res = self.cpu.get_int_value(deadframe, 0) assert res == -42 + NUM
def test_evenodd_pair_extensive(self, value): instrs = [] failargs = [] values = [] j = 0 mapping = (('int_floordiv',lambda x,y: x // y), ('int_mod', lambda x,y: x % y), ('int_mul_ovf', lambda x,y: x * y)) for i in range(20): name, func = mapping[j] instrs.append("i{d} = {i}(i0, {d})".format(d=i+1, i=name)) values.append((name, func(value, i+1))) failargs.append("i" + str(i+1)) j += 1 if j >= len(mapping): j = 0 code = """ [i0] {instrs} i99 = int_add(i0, 1) i100 = int_eq(i0,i99) guard_true(i100) [{failargs}] # will always fail!! finish(i0, descr=faildescr) """.format(instrs=('\n' +' '*8).join(instrs), failargs=','.join(failargs)) # 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, value) fail = self.cpu.get_latest_descr(deadframe) for i,(name, v) in enumerate(values): assert self.cpu.get_int_value(deadframe, i) == v
def test_unicodesetitem_really_needs_temploc(self): u_box = self.alloc_unicode(u"abcdsdasdsaddefg") targettoken = TargetToken() finaldescr = BasicFinalDescr(1) loop = parse(''' [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10] label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10, descr=targettoken) unicodesetitem(p10, i6, 123) i11 = int_add(i0, i1) i12 = int_add(i11, i2) i13 = int_add(i12, i3) i14 = int_add(i13, i4) i15 = int_add(i14, i5) i16 = int_add(i15, i6) i17 = int_add(i16, i7) i18 = int_add(i17, i8) i19 = int_add(i18, i9) finish(i19, descr=finaldescr) ''', namespace={ 'targettoken': targettoken, 'finaldescr': finaldescr }) looptoken = JitCellToken() args = [(i + 1) for i in range(10)] + [u_box.getref_base()] self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, *args) fail = self.cpu.get_latest_descr(deadframe) assert fail.identifier == 1 res = self.cpu.get_int_value(deadframe, 0) assert res == sum(args[:10])
def test_unicodesetitem_really_needs_temploc(self): u_box = self.alloc_unicode(u"abcdsdasdsaddefg") targettoken = TargetToken() finaldescr = BasicFinalDescr(1) loop = parse(''' [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10] label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10, descr=targettoken) unicodesetitem(p10, i6, 123) i11 = int_add(i0, i1) i12 = int_add(i11, i2) i13 = int_add(i12, i3) i14 = int_add(i13, i4) i15 = int_add(i14, i5) i16 = int_add(i15, i6) i17 = int_add(i16, i7) i18 = int_add(i17, i8) i19 = int_add(i18, i9) finish(i19, descr=finaldescr) ''', namespace={'targettoken': targettoken, 'finaldescr': finaldescr}) looptoken = JitCellToken() args = [(i + 1) for i in range(10)] + [u_box.getref_base()] self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, *args) fail = self.cpu.get_latest_descr(deadframe) assert fail.identifier == 1 res = self.cpu.get_int_value(deadframe, 0) assert res == sum(args[:10])
def test_compile_more_than_32k(self): # the guard_true needs a "b.cond" jumping forward more than 32 kb looptoken = JitCellToken() targettoken = TargetToken() ops = [ '[i0]', 'label(i0, descr=targettoken)', 'i1 = int_le(i0, 9)', 'guard_true(i1, descr=faildescr) [i0]', ] NUM = 8193 iprevious = 'i0' for i in range(NUM): inext = 'i%d' % (i + 2, ) ops.append('%s = int_add(%s, 1)' % (inext, iprevious)) iprevious = inext ops.append('jump(%s, descr=targettoken)' % (iprevious, )) loop = parse('\n'.join(ops), namespace={ 'targettoken': targettoken, 'faildescr': BasicFailDescr(5) }) self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, -42) fail = self.cpu.get_latest_descr(deadframe) assert fail.identifier == 5 res = self.cpu.get_int_value(deadframe, 0) assert res == -42 + NUM
def test_compile_loop_many_int_args(self): for numargs in range(2, 30): ops = [] arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)]) ops.append(arglist) arg1 = 0 arg2 = 1 res = numargs for i in range(numargs - 1): op = "i%d = int_add(i%d, i%d)\n" % (res, arg1, arg2) arg1 = res res += 1 arg2 += 1 ops.append(op) ops.append("finish(i%d)" % (res - 1)) ops = "".join(ops) loop = parse(ops) looptoken = JitCellToken() 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) assert self.cpu.get_int_value(deadframe, 0) == sum(args)
def test_compile_loop_many_int_args(self): for numargs in range(2, 30): ops = [] arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)]) ops.append(arglist) arg1 = 0 arg2 = 1 res = numargs for i in range(numargs - 1): op = "i%d = int_add(i%d, i%d)\n" % (res, arg1, arg2) arg1 = res res += 1 arg2 += 1 ops.append(op) ops.append("finish(i%d)" % (res - 1)) ops = "".join(ops) loop = parse(ops) looptoken = JitCellToken() 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) assert self.cpu.get_int_value(deadframe, 0) == sum(args)
def run(inputargs, ops): cpu = CPU(None, None) cpu.setup_once() loop = parse(ops, cpu, namespace=locals()) looptoken = JitCellToken() cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = cpu.execute_token(looptoken, *inputargs) return cpu, deadframe
def test_redirect_call_assembler2(self): def assembler_helper(deadframe, virtualizable): x = self.cpu.get_int_value(deadframe, 0) assert x == 11 return 7 FUNCPTR = lltype.Ptr( lltype.FuncType([llmemory.GCREF, 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) FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof( lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), [lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL) lt1, lt2, lt3 = [JitCellToken() for x in range(3)] lt2.outermost_jitdriver_sd = FakeJitDriverSD() loop1 = parse(''' [i0] i1 = call_assembler_i(i0, descr=lt2) guard_not_forced()[] finish(i1) ''', namespace=locals()) loop2 = parse(''' [i0] i1 = int_add(i0, 1) finish(i1) ''') loop3 = parse(''' [i0] i1 = int_sub(i0, 1) finish(i1) ''') self.cpu.compile_loop(loop2.inputargs, loop2.operations, lt2) self.cpu.compile_loop(loop3.inputargs, loop3.operations, lt3) self.cpu.compile_loop(loop1.inputargs, loop1.operations, lt1) df = self.cpu.execute_token(lt1, 10) assert self.cpu.get_int_value(df, 0) == 7 self.cpu.redirect_call_assembler(lt2, lt3) df = self.cpu.execute_token(lt1, 12) assert self.cpu.get_int_value(df, 0) == 7
def test_call_aligned_with_spilled_values(self): cpu = self.cpu if not cpu.supports_floats: py.test.skip('requires floats') def func(*args): return float(sum(args)) F = lltype.Float I = lltype.Signed floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56] ints = [7, 11, 23, 13, -42, 1111, 95, 1] for case in range(256): local_floats = list(floats) local_ints = list(ints) args = [] spills = [] funcargs = [] float_count = 0 int_count = 0 for i in range(8): if case & (1<<i): args.append('f%d' % float_count) spills.append('force_spill(f%d)' % float_count) float_count += 1 funcargs.append(F) else: args.append('i%d' % int_count) spills.append('force_spill(i%d)' % int_count) int_count += 1 funcargs.append(I) arguments = ', '.join(args) spill_ops = '\n'.join(spills) FUNC = self.FuncType(funcargs, F) FPTR = self.Ptr(FUNC) func_ptr = llhelper(FPTR, func) calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, EffectInfo.MOST_GENERAL) funcbox = self.get_funcbox(cpu, func_ptr) ops = '[%s]\n' % arguments ops += '%s\n' % spill_ops ops += 'f99 = call_f(ConstClass(func_ptr), %s, descr=calldescr)\n' % arguments ops += 'i99 = same_as_i(0)\n' ops += 'guard_true(i99) [f99, %s]\n' % arguments ops += 'finish()\n' loop = parse(ops, namespace=locals()) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) argvals, expected_result = self._prepare_args(args, floats, ints) deadframe = self.cpu.execute_token(looptoken, *argvals) x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0)) assert abs(x - expected_result) < 0.0001
def test_call_aligned_with_spilled_values(self): cpu = self.cpu if not cpu.supports_floats: py.test.skip('requires floats') def func(*args): return float(sum(args)) F = lltype.Float I = lltype.Signed floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56] ints = [7, 11, 23, 13, -42, 1111, 95, 1] for case in range(256): local_floats = list(floats) local_ints = list(ints) args = [] spills = [] funcargs = [] float_count = 0 int_count = 0 for i in range(8): if case & (1 << i): args.append('f%d' % float_count) spills.append('force_spill(f%d)' % float_count) float_count += 1 funcargs.append(F) else: args.append('i%d' % int_count) spills.append('force_spill(i%d)' % int_count) int_count += 1 funcargs.append(I) arguments = ', '.join(args) spill_ops = '\n'.join(spills) FUNC = self.FuncType(funcargs, F) FPTR = self.Ptr(FUNC) func_ptr = llhelper(FPTR, func) calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, EffectInfo.MOST_GENERAL) funcbox = self.get_funcbox(cpu, func_ptr) ops = '[%s]\n' % arguments ops += '%s\n' % spill_ops ops += 'f99 = call(ConstClass(func_ptr), %s, descr=calldescr)\n' % arguments ops += 'i99 = same_as(0)\n' ops += 'guard_true(i99) [f99, %s]\n' % arguments ops += 'finish()\n' loop = parse(ops, namespace=locals()) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) argvals, expected_result = self._prepare_args(args, floats, ints) deadframe = self.cpu.execute_token(looptoken, *argvals) x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0)) assert abs(x - expected_result) < 0.0001
def parse(self, s, boxkinds=None, want_fail_descr=True): if want_fail_descr: invent_fail_descr = self.invent_fail_descr else: invent_fail_descr = lambda *args: None return parse(s, self.cpu, self.namespace, type_system=self.type_system, boxkinds=boxkinds, invent_fail_descr=invent_fail_descr)
def test_redirect_call_assembler2(self): def assembler_helper(deadframe, virtualizable): x = self.cpu.get_int_value(deadframe, 0) assert x == 11 return 7 FUNCPTR = lltype.Ptr(lltype.FuncType([llmemory.GCREF, 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) FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof( lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), [lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL) lt1, lt2, lt3 = [JitCellToken() for x in range(3)] lt2.outermost_jitdriver_sd = FakeJitDriverSD() loop1 = parse(''' [i0] i1 = call_assembler_i(i0, descr=lt2) guard_not_forced()[] finish(i1) ''', namespace=locals()) loop2 = parse(''' [i0] i1 = int_add(i0, 1) finish(i1) ''') loop3 = parse(''' [i0] i1 = int_sub(i0, 1) finish(i1) ''') self.cpu.compile_loop(loop2.inputargs, loop2.operations, lt2) self.cpu.compile_loop(loop3.inputargs, loop3.operations, lt3) self.cpu.compile_loop(loop1.inputargs, loop1.operations, lt1) df = self.cpu.execute_token(lt1, 10) assert self.cpu.get_int_value(df, 0) == 7 self.cpu.redirect_call_assembler(lt2, lt3) df = self.cpu.execute_token(lt1, 12) assert self.cpu.get_int_value(df, 0) == 7
def test_label_float_in_reg_and_on_stack(self): targettoken = TargetToken() ops = """ [i0, f3] i2 = same_as_i(i0) # but forced to be in a register force_spill(i2) force_spill(f3) f4 = float_add(f3, 5.0) label(f3, f4, descr=targettoken) force_spill(f3) f5 = same_as_f(f3) # but forced to be in a register finish(f5) """ faildescr = BasicFailDescr(2) loop = parse(ops, self.cpu, namespace=locals()) looptoken = JitCellToken() info = self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) ops2 = """ [i0, f1] i1 = same_as_i(i0) f2 = same_as_f(f1) f3 = float_add(f1, 10.0) force_spill(f3) force_spill(i1) f4 = float_add(f3, f1) jump(f3, f4, descr=targettoken) """ loop2 = parse(ops2, self.cpu, namespace=locals()) looptoken2 = JitCellToken() info = self.cpu.compile_loop(loop2.inputargs, loop2.operations, looptoken2) deadframe = self.cpu.execute_token(looptoken, -9, longlong.getfloatstorage(-13.5)) res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0)) assert res == -13.5 # deadframe = self.cpu.execute_token(looptoken2, -9, longlong.getfloatstorage(-13.5)) res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0)) assert res == -3.5
def consider_category(log, options, category): loops = logparser.extract_category(log, category) if options.loopnum is None: input_loops = loops else: input_loops = [loops[options.loopnum]] loops = [parse(inp, no_namespace=True, nonstrict=True) for inp in input_loops] summary = {} for loop in loops: summary = loop.summary(summary) return loops, summary
def test_subi_range(self): for i in [-32769, -32768, -32767, 32767, 32768, 32769]: ops = ''' [i0] i1 = int_sub(i0, %d) i2 = int_sub_ovf(i1, %d) finish(i2) ''' % (i, i) loop = parse(ops, self.cpu, namespace=locals()) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, 10000000) assert self.cpu.get_int_value(deadframe, 0) == 10000000 - 2 * i
def consider_category(log, options, category): loops = logparser.extract_category(log, category) if options.loopnum is None: input_loops = loops else: input_loops = [loops[options.loopnum]] loops = [ parse(inp, no_namespace=True, nonstrict=True) for inp in input_loops ] summary = {} for loop in loops: summary = loop.summary(summary) return loops, summary
def _compile_and_run(self, source, args_values, float=True, ns={}): loop = parse(source, namespace=ns) cpu = self.CPUClass(rtyper=None, stats=None) cpu.setup_once() # looptoken = JitCellToken() cpu.compile_loop(loop.inputargs, loop.operations, looptoken) #import pdb; pdb.set_trace() deadframe = cpu.execute_token(looptoken, *args_values) print(source) if float: return cpu.get_float_value(deadframe, 0) else: return cpu.get_int_value(deadframe, 0)
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 test_call_aligned_explicit_check(self): if (not platform.machine().startswith('arm') and sys.maxint == 2 ** 31 - 1): # XXX is still necessary on x86? py.test.skip("libffi on 32bit is broken") cpu = self.cpu if not cpu.supports_floats: py.test.skip('requires floats') func_addr = self.make_function_returning_stack_pointer() F = lltype.Float I = lltype.Signed floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56] ints = [7, 11, 23, 13, -42, 1111, 95, 1] for case in range(256): args = [] funcargs = [] float_count = 0 int_count = 0 for i in range(8): if case & (1<<i): args.append('f%d' % float_count) float_count += 1 funcargs.append(F) else: args.append('i%d' % int_count) int_count += 1 funcargs.append(I) arguments = ', '.join(args) FUNC = self.FuncType(funcargs, I) calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, EffectInfo.MOST_GENERAL) ops = '[%s]\n' % arguments ops += 'i99 = call_i(%d, %s, descr=calldescr)\n' % (func_addr, arguments) ops += 'finish(i99)\n' loop = parse(ops, namespace=locals()) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) argvals, expected_result = self._prepare_args(args, floats, ints) deadframe = self.cpu.execute_token(looptoken, *argvals) x = cpu.get_int_value(deadframe, 0) align_req = self.get_alignment_requirements() assert x % align_req == 0
def test_call_aligned_explicit_check(self): if (not platform.machine().startswith('arm') and sys.maxint == 2**31 - 1): # XXX is still necessary on x86? py.test.skip("libffi on 32bit is broken") cpu = self.cpu if not cpu.supports_floats: py.test.skip('requires floats') func_addr = self.make_function_returning_stack_pointer() F = lltype.Float I = lltype.Signed floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56] ints = [7, 11, 23, 13, -42, 1111, 95, 1] for case in range(256): args = [] funcargs = [] float_count = 0 int_count = 0 for i in range(8): if case & (1 << i): args.append('f%d' % float_count) float_count += 1 funcargs.append(F) else: args.append('i%d' % int_count) int_count += 1 funcargs.append(I) arguments = ', '.join(args) FUNC = self.FuncType(funcargs, I) calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, EffectInfo.MOST_GENERAL) ops = '[%s]\n' % arguments ops += 'i99 = call(%d, %s, descr=calldescr)\n' % (func_addr, arguments) ops += 'finish(i99)\n' loop = parse(ops, namespace=locals()) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) argvals, expected_result = self._prepare_args(args, floats, ints) deadframe = self.cpu.execute_token(looptoken, *argvals) x = cpu.get_int_value(deadframe, 0) align_req = self.get_alignment_requirements() assert x % align_req == 0
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 test_int_mul_no_overflow_var_var(self, v1, v2): try: result = v1*v2 except OverflowError: py.test.skip("this test is not made to check the overflow!") code = """ [i0,i2] i1 = int_mul_ovf(i0,i2) finish(i1, descr=faildescr) """.format() loop = parse(code, namespace={"faildescr": BasicFinalDescr(1)}) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, v1, v2) fail = self.cpu.get_latest_descr(deadframe) assert self.cpu.get_int_value(deadframe, 0) == result
def test_int_mul_no_overflow_var_var(self, v1, v2): try: result = v1 * v2 except OverflowError: py.test.skip("this test is not made to check the overflow!") code = """ [i0,i2] i1 = int_mul_ovf(i0,i2) finish(i1, descr=faildescr) """.format() loop = parse(code, namespace={"faildescr": BasicFinalDescr(1)}) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, v1, v2) fail = self.cpu.get_latest_descr(deadframe) assert self.cpu.get_int_value(deadframe, 0) == result
def test_uint_rshift(self): code = """ [i1] i11 = int_and(i1, 63) i10 = uint_rshift(18, i11) i1402 = int_is_true(i10) guard_false(i1402, descr=faildescr) [] # must NEVER exit with i1 == 0 finish(i1402, descr=finishdescr) """ finishdescr = BasicFinalDescr(1) faildescr = BasicFailDescr(2) loop = parse(code, namespace={"faildescr": faildescr, "finishdescr": finishdescr}) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, 19) fail = self.cpu.get_latest_descr(deadframe) assert fail == finishdescr # ensures that guard is not taken!
def test_debugger_on(self): from rpython.tool.logparser import parse_log_file, extract_category from rpython.rlib import debug targettoken, preambletoken = TargetToken(), TargetToken() loop = """ [i0] label(i0, descr=preambletoken) debug_merge_point('xyz', 0, 0) i1 = int_add(i0, 1) i2 = int_ge(i1, 10) guard_false(i2) [] label(i1, descr=targettoken) debug_merge_point('xyz', 0, 0) i11 = int_add(i1, 1) i12 = int_ge(i11, 10) guard_false(i12) [] jump(i11, descr=targettoken) """ ops = parse(loop, namespace={ 'targettoken': targettoken, 'preambletoken': preambletoken }) debug._log = dlog = debug.DebugLog() try: self.cpu.assembler.set_debug(True) looptoken = JitCellToken() self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken) self.cpu.execute_token(looptoken, 0) # check debugging info struct = self.cpu.assembler.get_loop_run_counters(0) assert struct.i == 1 struct = self.cpu.assembler.get_loop_run_counters(1) assert struct.i == 1 struct = self.cpu.assembler.get_loop_run_counters(2) assert struct.i == 9 self.cpu.finish_once() finally: debug._log = None l0 = ('debug_print', 'entry -1:1') l1 = ('debug_print', preambletoken.repr_of_descr() + ':1') l2 = ('debug_print', targettoken.repr_of_descr() + ':9') assert ('jit-backend-counts', [l0, l1, l2]) in dlog
def main(argv): log = logparser.parse_log_file(argv[0]) parts = logparser.extract_category(log, "jit-log-opt-") for i, oplist in enumerate(parts): loop = parse(oplist, no_namespace=True, nonstrict=True) num_ops = 0 num_dmp = 0 num_guards = 0 for op in loop.operations: if op.getopnum() == rop.DEBUG_MERGE_POINT: num_dmp += 1 else: num_ops += 1 if op.is_guard(): num_guards += 1 if num_dmp == 0: print "Loop #%d, length: %d, opcodes: %d, guards: %d" % (i, num_ops, num_dmp, num_guards) else: print "Loop #%d, length: %d, opcodes: %d, guards: %d, %f" % (i, num_ops, num_dmp, num_guards, num_ops/num_dmp)
def test_compile_loop(): cpu = FakeCPU() staticdata = FakeMetaInterpStaticData() staticdata.all_descrs = LLtypeMixin.cpu.setup_descrs() staticdata.cpu = cpu staticdata.jitlog = jl.JitLogger(cpu) staticdata.jitlog.trace_id = 1 # loop = parse(''' [p1] i1 = getfield_gc_i(p1, descr=valuedescr) i2 = int_add(i1, 1) p2 = new_with_vtable(descr=nodesize) setfield_gc(p2, i2, descr=valuedescr) jump(p2) ''', namespace=LLtypeMixin.__dict__.copy()) # metainterp = FakeMetaInterp() metainterp.staticdata = staticdata metainterp.cpu = cpu metainterp.history = History() t = convert_loop_to_trace(loop, staticdata) metainterp.history.inputargs = t.inputargs metainterp.history.trace = t # greenkey = 'faked' target_token = compile_loop( metainterp, greenkey, (0, 0, 0), t.inputargs, [t._mapping[x] for x in loop.operations[-1].getarglist()], use_unroll=False) jitcell_token = target_token.targeting_jitcell_token assert jitcell_token == target_token.original_jitcell_token assert jitcell_token.target_tokens == [target_token] assert jitcell_token.number == 2 # assert len(cpu.seen) == 1 assert cpu.seen[0][2] == jitcell_token # del cpu.seen[:]
def test_debugger_on(self): py.test.skip("I don't care for now") from rpython.rlib import debug targettoken, preambletoken = TargetToken(), TargetToken() loop = """ [i0] label(i0, descr=preambletoken) debug_merge_point('xyz', 0) i1 = int_add(i0, 1) i2 = int_ge(i1, 10) guard_false(i2) [] label(i1, descr=targettoken) debug_merge_point('xyz', 0) i11 = int_add(i1, 1) i12 = int_ge(i11, 10) guard_false(i12) [] jump(i11, descr=targettoken) """ ops = parse(loop, namespace={'targettoken': targettoken, 'preambletoken': preambletoken}) debug._log = dlog = debug.DebugLog() try: self.cpu.assembler.set_debug(True) looptoken = JitCellToken() self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken) self.cpu.execute_token(looptoken, 0) # check debugging info struct = self.cpu.assembler.loop_run_counters[0] assert struct.i == 1 struct = self.cpu.assembler.loop_run_counters[1] assert struct.i == 1 struct = self.cpu.assembler.loop_run_counters[2] assert struct.i == 9 self.cpu.finish_once() finally: debug._log = None l0 = ('debug_print', 'entry -1:1') l1 = ('debug_print', preambletoken.repr_of_descr() + ':1') l2 = ('debug_print', targettoken.repr_of_descr() + ':9') assert ('jit-backend-counts', [l0, l1, l2]) in dlog
def main(argv): log = logparser.parse_log_file(argv[0]) parts = logparser.extract_category(log, "jit-log-opt-") for i, oplist in enumerate(parts): loop = parse(oplist, no_namespace=True, nonstrict=True) num_ops = 0 num_dmp = 0 num_guards = 0 for op in loop.operations: if op.getopnum() == rop.DEBUG_MERGE_POINT: num_dmp += 1 else: num_ops += 1 if op.is_guard(): num_guards += 1 if num_dmp == 0: print "Loop #%d, length: %d, opcodes: %d, guards: %d" % ( i, num_ops, num_dmp, num_guards) else: print "Loop #%d, length: %d, opcodes: %d, guards: %d, %f" % ( i, num_ops, num_dmp, num_guards, num_ops / num_dmp)
def test_uint_rshift(self): code = """ [i1] i11 = int_and(i1, 63) i10 = uint_rshift(18, i11) i1402 = int_is_true(i10) guard_false(i1402, descr=faildescr) [] # must NEVER exit with i1 == 0 finish(i1402, descr=finishdescr) """ finishdescr = BasicFinalDescr(1) faildescr = BasicFailDescr(2) loop = parse(code, namespace={ 'faildescr': faildescr, 'finishdescr': finishdescr }) looptoken = JitCellToken() self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken) deadframe = self.cpu.execute_token(looptoken, 19) fail = self.cpu.get_latest_descr(deadframe) assert fail == finishdescr # ensures that guard is not taken!
def test_compile_loop(): cpu = FakeCPU() staticdata = FakeMetaInterpStaticData() staticdata.cpu = cpu staticdata.globaldata = FakeGlobalData() staticdata.globaldata.loopnumbering = 1 # loop = parse(''' [p1] i1 = getfield_gc(p1, descr=valuedescr) i2 = int_add(i1, 1) p2 = new_with_vtable(ConstClass(node_vtable)) setfield_gc(p2, i2, descr=valuedescr) jump(p2) ''', namespace=LLtypeMixin.__dict__.copy()) # metainterp = FakeMetaInterp() metainterp.staticdata = staticdata metainterp.cpu = cpu metainterp.history = History() metainterp.history.operations = loop.operations[:-1] metainterp.history.inputargs = loop.inputargs[:] cpu.tracker._all_size_descrs_with_vtable = ( LLtypeMixin.cpu.tracker._all_size_descrs_with_vtable) # greenkey = 'faked' target_token = compile_loop(metainterp, greenkey, 0, loop.inputargs, loop.operations[-1].getarglist(), None) jitcell_token = target_token.targeting_jitcell_token assert jitcell_token == target_token.original_jitcell_token assert jitcell_token.target_tokens == [target_token] assert jitcell_token.number == 1 assert staticdata.globaldata.loopnumbering == 2 # assert len(cpu.seen) == 1 assert cpu.seen[0][2] == jitcell_token # del cpu.seen[:]
def test_compile_loop(): cpu = FakeCPU() staticdata = FakeMetaInterpStaticData() staticdata.cpu = cpu staticdata.globaldata = FakeGlobalData() staticdata.globaldata.loopnumbering = 1 # loop = parse(''' [p1] i1 = getfield_gc_i(p1, descr=valuedescr) i2 = int_add(i1, 1) p2 = new_with_vtable(descr=nodesize) setfield_gc(p2, i2, descr=valuedescr) jump(p2) ''', namespace=LLtypeMixin.__dict__.copy()) # metainterp = FakeMetaInterp() metainterp.staticdata = staticdata metainterp.cpu = cpu metainterp.history = History() t = convert_loop_to_trace(loop, staticdata) metainterp.history.inputargs = t.inputargs metainterp.history.trace = t # greenkey = 'faked' target_token = compile_loop(metainterp, greenkey, (0, 0, 0), t.inputargs, [t._mapping[x] for x in loop.operations[-1].getarglist()], None) jitcell_token = target_token.targeting_jitcell_token assert jitcell_token == target_token.original_jitcell_token assert jitcell_token.target_tokens == [target_token] assert jitcell_token.number == 1 assert staticdata.globaldata.loopnumbering == 2 # assert len(cpu.seen) == 1 assert cpu.seen[0][2] == jitcell_token # del cpu.seen[:]
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_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 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_descr = self.cpu.sizeof(O, True) o_vtable = globals()['o_vtable'] # 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, []) remap = {} for a, b in zip(ops.inputargs, expected.inputargs): remap[b] = a equaloplists(operations, expected.operations, remap=remap) lltype.free(frame_info, flavor='raw')
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 parse(self, s, boxkinds=None, namespace=None): return parse(s, self.cpu, namespace or self.namespace, type_system=self.type_system, boxkinds=boxkinds)
def parse(self, s, boxkinds=None): return parse(s, self.cpu, self.namespace, type_system=self.type_system, boxkinds=boxkinds, invent_fail_descr=self.invent_fail_descr)
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}) 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() token2 = JitCellToken() token3 = JitCellToken() token4 = JitCellToken() cpu.compile_loop(loop1.inputargs, loop1.operations, token1) 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())), (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' '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 parse(self, *args, **kwds): kwds['OpParser'] = self.OpParser return parse(*args, **kwds)
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 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=BasicFailDescr()) 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 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) # 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 parse(self, s, boxkinds=None, namespace=None): return parse(s, self.cpu, namespace or self.namespace, boxkinds=boxkinds)
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 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) 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_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 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 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 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')