def test_arrayitems(self): TP = lltype.GcArray(lltype.Signed) ofs = symbolic.get_field_token(TP, 'length', False)[0] itemsofs = symbolic.get_field_token(TP, 'items', False)[0] descr = self.cpu.arraydescrof(TP) res = self.execute_operation(rop.NEW_ARRAY, [ConstInt(10)], 'ref', descr) resbuf = self._resbuf(res) assert resbuf[ofs / WORD] == 10 self.execute_operation(rop.SETARRAYITEM_GC, [res, ConstInt(2), BoxInt(38)], 'void', descr) assert resbuf[itemsofs / WORD + 2] == 38 self.execute_operation(rop.SETARRAYITEM_GC, [res, BoxInt(3), BoxInt(42)], 'void', descr) assert resbuf[itemsofs / WORD + 3] == 42 r = self.execute_operation(rop.GETARRAYITEM_GC, [res, ConstInt(2)], 'int', descr) assert r.value == 38 r = self.execute_operation(rop.GETARRAYITEM_GC, [res.constbox(), BoxInt(2)], 'int', descr) assert r.value == 38 r = self.execute_operation( rop.GETARRAYITEM_GC, [res.constbox(), ConstInt(2)], 'int', descr) assert r.value == 38 r = self.execute_operation(rop.GETARRAYITEM_GC, [res, BoxInt(2)], 'int', descr) assert r.value == 38 r = self.execute_operation(rop.GETARRAYITEM_GC, [res, BoxInt(3)], 'int', descr) assert r.value == 42
def getvar(self, arg): if not arg: return ConstInt(0) try: return ConstInt(int(arg)) except ValueError: if self.is_float(arg): return ConstFloat(float(arg)) if arg.startswith('"') or arg.startswith("'"): # XXX ootype info = arg.strip("'\"") return ConstPtr( lltype.cast_opaque_ptr(llmemory.GCREF, llstr(info))) if arg.startswith('ConstClass('): name = arg[len('ConstClass('):-1] return self.get_const(name, 'class') elif arg == 'None': return None elif arg == 'NULL': if self.type_system == 'lltype': return ConstPtr(ConstPtr.value) else: return ConstObj(ConstObj.value) elif arg.startswith('ConstPtr('): name = arg[len('ConstPtr('):-1] return self.get_const(name, 'ptr') return self.vars[arg]
def test_virtuals_with_equal_fields(self): info1 = VirtualStateInfo(ConstInt(42), [1, 2]) value = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) info1.fieldstate = [knownclass_info, knownclass_info] vstate1 = VirtualState([info1]) assert vstate1.generalization_of(vstate1) info2 = VirtualStateInfo(ConstInt(42), [1, 2]) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) info2.fieldstate = [unknown_info1, unknown_info1] vstate2 = VirtualState([info2]) assert vstate2.generalization_of(vstate2) assert not vstate1.generalization_of(vstate2) assert vstate2.generalization_of(vstate1) info3 = VirtualStateInfo(ConstInt(42), [1, 2]) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) unknown_info2 = NotVirtualStateInfo(OptValue(self.nodebox)) info3.fieldstate = [unknown_info1, unknown_info2] vstate3 = VirtualState([info3]) assert vstate3.generalization_of(vstate2) assert vstate3.generalization_of(vstate1) assert not vstate2.generalization_of(vstate3) assert not vstate1.generalization_of(vstate3)
def gen_malloc_nursery(self, size, v_result): """Try to generate or update a CALL_MALLOC_NURSERY. If that fails, generate a plain CALL_MALLOC_GC instead. """ size = self.round_up_for_allocation(size) if not self.gc_ll_descr.can_use_nursery_malloc(size): return False # op = None if self._op_malloc_nursery is not None: # already a MALLOC_NURSERY: increment its total size total_size = self._op_malloc_nursery.getarg(0).getint() total_size += size if self.gc_ll_descr.can_use_nursery_malloc(total_size): # if the total size is still reasonable, merge it self._op_malloc_nursery.setarg(0, ConstInt(total_size)) op = ResOperation(rop.INT_ADD, [ self._v_last_malloced_nursery, ConstInt(self._previous_size) ], v_result) if op is None: # if we failed to merge with a previous MALLOC_NURSERY, emit one self.emitting_an_operation_that_can_collect() op = ResOperation(rop.CALL_MALLOC_NURSERY, [ConstInt(size)], v_result) self._op_malloc_nursery = op # self.newops.append(op) self._previous_size = size self._v_last_malloced_nursery = v_result self.recent_mallocs[v_result] = None return True
def test_position_generalization(self): def postest(info1, info2): info1.position = 0 assert info1.generalization_of(info1, {}, {}) info2.position = 0 assert info1.generalization_of(info2, {}, {}) info2.position = 1 renum = {} assert info1.generalization_of(info2, renum, {}) assert renum == {0:1} assert info1.generalization_of(info2, {0:1}, {}) assert info1.generalization_of(info2, {1:1}, {}) bad = {} assert not info1.generalization_of(info2, {0:0}, bad) assert info1 in bad and info2 in bad for BoxType in (BoxInt, BoxFloat, BoxPtr): info1 = NotVirtualStateInfo(OptValue(BoxType())) info2 = NotVirtualStateInfo(OptValue(BoxType())) postest(info1, info2) info1, info2 = VArrayStateInfo(42), VArrayStateInfo(42) info1.fieldstate = info2.fieldstate = [] postest(info1, info2) info1, info2 = VStructStateInfo(42, []), VStructStateInfo(42, []) info1.fieldstate = info2.fieldstate = [] postest(info1, info2) info1, info2 = VirtualStateInfo(ConstInt(42), []), VirtualStateInfo(ConstInt(42), []) info1.fieldstate = info2.fieldstate = [] postest(info1, info2)
def make_storage(b1, b2, b3): storage = Storage() snapshot = Snapshot(None, [b1, ConstInt(1), b1, b2]) snapshot = Snapshot(snapshot, [ConstInt(2), ConstInt(3)]) snapshot = Snapshot(snapshot, [b1, b2, b3]) storage.rd_snapshot = snapshot return storage
def test_virtual_adder_no_op_renaming(): b1s, b2s, b3s = [BoxInt(1), BoxInt(2), BoxInt(3)] storage = make_storage(b1s, b2s, b3s) memo = ResumeDataLoopMemo(LLtypeMixin.cpu) modifier = ResumeDataVirtualAdder(storage, memo) b1_2 = BoxInt() class FakeValue(object): def is_virtual(self): return False def get_key_box(self): return b1_2 val = FakeValue() values = {b1s: val, b2s: val} liveboxes = modifier.finish(values) assert storage.rd_snapshot is None b1t, b3t = [BoxInt(11), BoxInt(33)] newboxes = _resume_remap(liveboxes, [b1_2, b3s], b1t, b3t) metainterp = MyMetaInterp() reader = ResumeDataReader(storage, newboxes, metainterp) lst = reader.consume_boxes() assert lst == [b1t, b1t, b3t] lst = reader.consume_boxes() assert lst == [ConstInt(2), ConstInt(3)] lst = reader.consume_boxes() assert lst == [b1t, ConstInt(1), b1t, b1t] assert metainterp.trace == []
def test_rebuild_from_resumedata_with_virtualizable(): b1, b2, b3, b4 = [BoxInt(), BoxPtr(), BoxInt(), BoxPtr()] c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)] storage = Storage() fs = [ FakeFrame("code0", 0, -1, b1, c1, b2), FakeFrame("code1", 3, 7, b3, c2, b1), FakeFrame("code2", 9, -1, c3, b2) ] capture_resumedata(fs, [b4], storage) memo = ResumeDataLoopMemo(LLtypeMixin.cpu) modifier = ResumeDataVirtualAdder(storage, memo) liveboxes = modifier.finish({}) metainterp = MyMetaInterp() b1t, b2t, b3t, b4t = [BoxInt(), BoxPtr(), BoxInt(), BoxPtr()] newboxes = _resume_remap(liveboxes, [b1, b2, b3, b4], b1t, b2t, b3t, b4t) result = rebuild_from_resumedata(metainterp, newboxes, storage, True) assert result == [b4t] fs2 = [ FakeFrame("code0", 0, -1, b1t, c1, b2t), FakeFrame("code1", 3, 7, b3t, c2, b1t), FakeFrame("code2", 9, -1, c3, b2t) ] assert metainterp.framestack == fs2
def test_ops_offset(self): from pypy.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*(getfield_raw/int_add/setfield_raw) + ops + None assert len(ops_offset) == 2*3 + len(operations) + 1 assert (ops_offset[operations[0]] <= ops_offset[operations[1]] <= ops_offset[operations[2]] <= ops_offset[None])
def test_rebuild_from_resumedata_two_guards_w_shared_virtuals(): b1, b2, b3, b4, b5, b6 = [BoxPtr(), BoxPtr(), BoxInt(), BoxPtr(), BoxInt(), BoxInt()] c1, c2, c3, c4 = [ConstInt(1), ConstInt(2), ConstInt(3), LLtypeMixin.nodebox.constbox()] storage = Storage() fs = [FakeFrame("code0", 0, -1, c1, b2, b3)] capture_resumedata(fs, None, [], storage) memo = ResumeDataLoopMemo(FakeMetaInterpStaticData()) values = {b2: virtual_value(b2, b5, c4)} modifier = ResumeDataVirtualAdder(storage, memo) liveboxes = modifier.finish(values) assert len(storage.rd_virtuals) == 1 assert storage.rd_virtuals[0].fieldnums == [tag(-1, TAGBOX), tag(0, TAGCONST)] storage2 = Storage() fs = [FakeFrame("code0", 0, -1, b1, b4, b2)] capture_resumedata(fs, None, [], storage2) values[b4] = virtual_value(b4, b6, c4) modifier = ResumeDataVirtualAdder(storage2, memo) liveboxes = modifier.finish(values) assert len(storage2.rd_virtuals) == 2 assert storage2.rd_virtuals[1].fieldnums == storage.rd_virtuals[0].fieldnums assert storage2.rd_virtuals[1] is storage.rd_virtuals[0]
def gen_malloc_fixedsize(self, size, v_result): """Generate a CALL_MALLOC_GC(malloc_fixedsize_fn, Const(size)). Note that with the framework GC, this should be called very rarely. """ addr = self.gc_ll_descr.get_malloc_fn_addr('malloc_fixedsize') self._gen_call_malloc_gc( [ConstInt(addr), ConstInt(size)], v_result, self.gc_ll_descr.malloc_fixedsize_descr)
def gen_boehm_malloc_array(self, arraydescr, v_num_elem, v_result): """Generate a CALL_MALLOC_GC(malloc_array_fn, ...) for Boehm.""" addr = self.gc_ll_descr.get_malloc_fn_addr('malloc_array') self._gen_call_malloc_gc([ ConstInt(addr), ConstInt(arraydescr.basesize), v_num_elem, ConstInt(arraydescr.itemsize), ConstInt(arraydescr.lendescr.offset) ], v_result, self.gc_ll_descr.malloc_array_descr)
def produce_into(self, builder, r): v_length = builder.get_index(10, r) v_ptr = builder.do(self.opnum, [v_length]) getattr(builder, self.builder_cache).append(v_ptr) # Initialize the string. Is there a better way to do this? for i in range(v_length.getint()): v_index = ConstInt(i) v_char = ConstInt(r.random_integer() % self.max) builder.do(self.set_char, [v_ptr, v_index, v_char])
def test_compile_tmp_callback(): from pypy.jit.codewriter import heaptracker from pypy.jit.backend.llgraph import runner from pypy.rpython.lltypesystem import lltype, llmemory from pypy.rpython.annlowlevel import llhelper from pypy.rpython.llinterp import LLException # cpu = runner.LLtypeCPU(None) FUNC = lltype.FuncType([lltype.Signed] * 4, lltype.Signed) def ll_portal_runner(g1, g2, r3, r4): assert (g1, g2, r3, r4) == (12, 34, -156, -178) if raiseme: raise raiseme else: return 54321 # class FakeJitDriverSD: portal_runner_ptr = llhelper(lltype.Ptr(FUNC), ll_portal_runner) portal_runner_adr = llmemory.cast_ptr_to_adr(portal_runner_ptr) portal_calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, None) portal_finishtoken = compile.DoneWithThisFrameDescrInt() num_red_args = 2 result_type = INT # loop_token = compile_tmp_callback( cpu, FakeJitDriverSD(), [ConstInt(12), ConstInt(34)], "ii") # raiseme = None # only two arguments must be passed in fail_descr = cpu.execute_token(loop_token, -156, -178) assert fail_descr is FakeJitDriverSD().portal_finishtoken # EXC = lltype.GcStruct('EXC') llexc = lltype.malloc(EXC) raiseme = LLException("exception class", llexc) fail_descr = cpu.execute_token(loop_token, -156, -178) assert isinstance(fail_descr, compile.PropagateExceptionDescr) got = cpu.grab_exc_value() assert lltype.cast_opaque_ptr(lltype.Ptr(EXC), got) == llexc # class FakeMetaInterpSD: class ExitFrameWithExceptionRef(Exception): pass FakeMetaInterpSD.cpu = cpu fail_descr = cpu.execute_token(loop_token, -156, -178) try: fail_descr.handle_fail(FakeMetaInterpSD(), None) except FakeMetaInterpSD.ExitFrameWithExceptionRef, e: assert lltype.cast_opaque_ptr(lltype.Ptr(EXC), e.args[1]) == llexc
def test_allocations(self): from pypy.rpython.lltypesystem import rstr allocs = [None] all = [] def f(size): allocs.insert(0, size) buf = ctypes.create_string_buffer(size) all.append(buf) return ctypes.cast(buf, ctypes.c_void_p).value func = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)(f) addr = ctypes.cast(func, ctypes.c_void_p).value try: saved_addr = self.cpu.assembler.malloc_func_addr self.cpu.assembler.malloc_func_addr = addr ofs = symbolic.get_field_token(rstr.STR, 'chars', False)[0] res = self.execute_operation(rop.NEWSTR, [ConstInt(7)], 'ref') assert allocs[0] == 7 + ofs + WORD resbuf = self._resbuf(res) assert resbuf[ofs / WORD] == 7 # ------------------------------------------------------------ res = self.execute_operation(rop.NEWSTR, [BoxInt(7)], 'ref') assert allocs[0] == 7 + ofs + WORD resbuf = self._resbuf(res) assert resbuf[ofs / WORD] == 7 # ------------------------------------------------------------ TP = lltype.GcArray(lltype.Signed) ofs = symbolic.get_field_token(TP, 'length', False)[0] descr = self.cpu.arraydescrof(TP) res = self.execute_operation(rop.NEW_ARRAY, [ConstInt(10)], 'ref', descr) assert allocs[0] == 10 * WORD + ofs + WORD resbuf = self._resbuf(res) assert resbuf[ofs / WORD] == 10 # ------------------------------------------------------------ res = self.execute_operation(rop.NEW_ARRAY, [BoxInt(10)], 'ref', descr) assert allocs[0] == 10 * WORD + ofs + WORD resbuf = self._resbuf(res) assert resbuf[ofs / WORD] == 10 finally: self.cpu.assembler.malloc_func_addr = saved_addr
def get_int_tests(): for opnum, args, retvalue in (list(_int_binary_operations()) + list(_int_comparison_operations()) + list(_int_unary_operations())): yield opnum, [BoxInt(x) for x in args], retvalue if len(args) > 1: assert len(args) == 2 yield opnum, [BoxInt(args[0]), ConstInt(args[1])], retvalue yield opnum, [ConstInt(args[0]), BoxInt(args[1])], retvalue if args[0] == args[1]: commonbox = BoxInt(args[0]) yield opnum, [commonbox, commonbox], retvalue
def test_unicode(self): ofs = symbolic.get_field_token(rstr.UNICODE, 'chars', False)[0] u = rstr.mallocunicode(13) for i in range(13): u.chars[i] = unichr(ord(u'a') + i) b = BoxPtr(lltype.cast_opaque_ptr(llmemory.GCREF, u)) r = self.execute_operation(rop.UNICODEGETITEM, [b, ConstInt(2)], 'int') assert r.value == ord(u'a') + 2 self.execute_operation(rop.UNICODESETITEM, [b, ConstInt(2), ConstInt(ord(u'z'))], 'void') assert u.chars[2] == u'z' assert u.chars[3] == u'd'
def _strgetitem(string_optimizer, strbox, indexbox, mode, resbox=None): if isinstance(strbox, ConstPtr) and isinstance(indexbox, ConstInt): if mode is mode_string: s = strbox.getref(lltype.Ptr(rstr.STR)) return ConstInt(ord(s.chars[indexbox.getint()])) else: s = strbox.getref(lltype.Ptr(rstr.UNICODE)) return ConstInt(ord(s.chars[indexbox.getint()])) if resbox is None: resbox = BoxInt() string_optimizer.emit_operation( ResOperation(mode.STRGETITEM, [strbox, indexbox], resbox)) return resbox
def test_stringitems(self): from pypy.rpython.lltypesystem.rstr import STR ofs = symbolic.get_field_token(STR, 'chars', False)[0] ofs_items = symbolic.get_field_token(STR.chars, 'items', False)[0] res = self.execute_operation(rop.NEWSTR, [ConstInt(10)], 'ref') self.execute_operation(rop.STRSETITEM, [res, ConstInt(2), ConstInt(ord('d'))], 'void') resbuf = self._resbuf(res, ctypes.c_char) assert resbuf[ofs + ofs_items + 2] == 'd' self.execute_operation(rop.STRSETITEM, [res, BoxInt(2), ConstInt(ord('z'))], 'void') assert resbuf[ofs + ofs_items + 2] == 'z' r = self.execute_operation(rop.STRGETITEM, [res, BoxInt(2)], 'int') assert r.value == ord('z')
def test_virtual_adder_make_varray(): b2s, b4s = [BoxPtr(), BoxInt(4)] c1s = ConstInt(111) storage = Storage() memo = ResumeDataLoopMemo(FakeMetaInterpStaticData()) modifier = ResumeDataVirtualAdder(storage, memo) modifier.liveboxes_from_env = {} modifier.liveboxes = {} modifier.vfieldboxes = {} class FakeOptimizer(object): class cpu: pass def new_const_item(self, descr): return None v2 = VArrayValue(FakeOptimizer(), LLtypeMixin.arraydescr, 2, b2s) v2._items = [b4s, c1s] modifier.register_virtual_fields(b2s, [b4s, c1s]) liveboxes = [] values = {b2s: v2} modifier._number_virtuals(liveboxes, values, 0) dump_storage(storage, liveboxes) storage.rd_consts = memo.consts[:] storage.rd_numb = None # resume b1t, b3t, b4t = [BoxInt(11), BoxInt(33), BoxInt(44)] newboxes = _resume_remap(liveboxes, [#b2s -- virtual b4s], b4t) # resume metainterp = MyMetaInterp() reader = ResumeDataReader(storage, newboxes, metainterp) assert len(reader.virtuals) == 1 b2t = reader._decode_box(tag(0, TAGVIRTUAL)) trace = metainterp.trace expected = [ (rop.NEW_ARRAY, [ConstInt(2)], b2t, LLtypeMixin.arraydescr), (rop.SETARRAYITEM_GC, [b2t,ConstInt(0), b4t],None, LLtypeMixin.arraydescr), (rop.SETARRAYITEM_GC, [b2t,ConstInt(1), c1s], None, LLtypeMixin.arraydescr), ] for x, y in zip(expected, trace): assert x == y # ptr = b2t.value._obj.container._as_ptr() assert lltype.typeOf(ptr) == lltype.Ptr(lltype.GcArray(lltype.Signed)) assert len(ptr) == 2 assert ptr[0] == 44 assert ptr[1] == 111
def gen_malloc_array(self, arraydescr, v_num_elem, v_result): """Generate a CALL_MALLOC_GC(malloc_array_fn, ...) going either to the standard or the nonstandard version of the function.""" # if (arraydescr.basesize == self.gc_ll_descr.standard_array_basesize and arraydescr.lendescr.offset == self.gc_ll_descr.standard_array_length_ofs): # this is a standard-looking array, common case addr = self.gc_ll_descr.get_malloc_fn_addr('malloc_array') args = [ ConstInt(addr), ConstInt(arraydescr.itemsize), ConstInt(arraydescr.tid), v_num_elem ] calldescr = self.gc_ll_descr.malloc_array_descr else: # rare case, so don't care too much about the number of arguments addr = self.gc_ll_descr.get_malloc_fn_addr( 'malloc_array_nonstandard') args = [ ConstInt(addr), ConstInt(arraydescr.basesize), ConstInt(arraydescr.itemsize), ConstInt(arraydescr.lendescr.offset), ConstInt(arraydescr.tid), v_num_elem ] calldescr = self.gc_ll_descr.malloc_array_nonstandard_descr self._gen_call_malloc_gc(args, v_result, calldescr)
def test_ResumeDataLoopMemo_ints(): memo = ResumeDataLoopMemo(LLtypeMixin.cpu) tagged = memo.getconst(ConstInt(44)) assert untag(tagged) == (44, TAGINT) tagged = memo.getconst(ConstInt(-3)) assert untag(tagged) == (-3, TAGINT) const = ConstInt(50000) tagged = memo.getconst(const) index, tagbits = untag(tagged) assert tagbits == TAGCONST assert memo.consts[index] is const tagged = memo.getconst(ConstInt(50000)) index2, tagbits = untag(tagged) assert tagbits == TAGCONST assert index2 == index
def test_we_are_jitted(self): def f(): if jit.we_are_jitted(): return 55 else: return 66 graphs = self.make_graphs(f, []) cw = CodeWriter(self.rtyper) cw.candidate_graphs = [graphs[0]] cw._start(self.metainterp_sd, None) jitcode = cw.make_one_bytecode((graphs[0], None), False) assert 'goto_if_not' not in jitcode._source assert ConstInt(55) in jitcode.constants assert ConstInt(66) not in jitcode.constants
def make_args_for_op(op, a, b): n=opname[op] if n[0:3] == 'INT' or n[0:4] == 'UINT': arg1 = ConstInt(a) arg2 = ConstInt(b) elif n[0:5] == 'FLOAT': arg1 = constfloat(float(a)) arg2 = constfloat(float(b)) elif n[0:3] == 'PTR': arg1 = ConstPtr(rffi.cast(llmemory.GCREF, a)) arg2 = ConstPtr(rffi.cast(llmemory.GCREF, b)) else: raise NotImplementedError( "Don't know how to make args for " + n) return arg1, arg2
def make_guards(self, box, guards): if self.has_lower and self.lower > MININT: bound = self.lower res = BoxInt() op = ResOperation(rop.INT_GE, [box, ConstInt(bound)], res) guards.append(op) op = ResOperation(rop.GUARD_TRUE, [res], None) guards.append(op) if self.has_upper and self.upper < MAXINT: bound = self.upper res = BoxInt() op = ResOperation(rop.INT_LE, [box, ConstInt(bound)], res) guards.append(op) op = ResOperation(rop.GUARD_TRUE, [res], None) guards.append(op)
def test_getfield_setfield(self): TP = lltype.GcStruct('x', ('s', lltype.Signed), ('i', rffi.INT), ('f', lltype.Float), ('u', rffi.USHORT), ('c1', lltype.Char), ('c2', lltype.Char), ('c3', lltype.Char)) res = self.execute_operation(rop.NEW, [], 'ref', self.cpu.sizeof(TP)) ofs_s = self.cpu.fielddescrof(TP, 's') ofs_i = self.cpu.fielddescrof(TP, 'i') #ofs_f = self.cpu.fielddescrof(TP, 'f') ofs_u = self.cpu.fielddescrof(TP, 'u') ofsc1 = self.cpu.fielddescrof(TP, 'c1') ofsc2 = self.cpu.fielddescrof(TP, 'c2') ofsc3 = self.cpu.fielddescrof(TP, 'c3') self.execute_operation(rop.SETFIELD_GC, [res, ConstInt(3)], 'void', ofs_s) # XXX ConstFloat #self.execute_operation(rop.SETFIELD_GC, [res, ofs_f, 1e100], 'void') # XXX we don't support shorts (at all) #self.execute_operation(rop.SETFIELD_GC, [res, ofs_u, ConstInt(5)], 'void') s = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofs_s) assert s.value == 3 self.execute_operation(rop.SETFIELD_GC, [res, BoxInt(3)], 'void', ofs_s) s = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofs_s) assert s.value == 3 self.execute_operation(rop.SETFIELD_GC, [res, BoxInt(1234)], 'void', ofs_i) i = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofs_i) assert i.value == 1234 #u = self.execute_operation(rop.GETFIELD_GC, [res, ofs_u], 'int') #assert u.value == 5 self.execute_operation(rop.SETFIELD_GC, [res, ConstInt(1)], 'void', ofsc1) self.execute_operation(rop.SETFIELD_GC, [res, ConstInt(3)], 'void', ofsc3) self.execute_operation(rop.SETFIELD_GC, [res, ConstInt(2)], 'void', ofsc2) c = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofsc1) assert c.value == 1 c = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofsc2) assert c.value == 2 c = self.execute_operation(rop.GETFIELD_GC, [res], 'int', ofsc3) assert c.value == 3
def constant(value): if isinstance(lltype.typeOf(value), lltype.Ptr): return ConstPtr(value) elif isinstance(ootype.typeOf(value), ootype.OOType): return ConstObj(ootype.cast_to_object(value)) else: return ConstInt(value)
def optimize_default(self, op): if op.is_always_pure(): for arg in op.args: if self.get_constant_box(arg) is None: break else: # all constant arguments: constant-fold away argboxes = [self.get_constant_box(arg) for arg in op.args] resbox = execute_nonspec(self.cpu, op.opnum, argboxes, op.descr) self.make_constant(op.result, resbox.constbox()) return # did we do the exact same operation already? args = op.args[:] for i in range(len(args)): arg = args[i] if arg in self.values: args[i] = self.values[arg].get_key_box() args.append(ConstInt(op.opnum)) oldop = self.pure_operations.get(args, None) if oldop is not None and oldop.descr is op.descr: assert oldop.opnum == op.opnum self.make_equal_to(op.result, self.getvalue(oldop.result)) return else: self.pure_operations[args] = op # otherwise, the operation remains self.emit_operation(op)
def produce_into(self, builder, r): if r.random() < 0.4: UnaryOperation.produce_into(self, builder, r) elif r.random() < 0.75 or not builder.cpu.supports_floats: self.put(builder, [ConstInt(r.random_integer())]) else: self.put(builder, [ConstFloat(r.random_float())])
def get_index(self, length, r): if length == 0: raise test_random.CannotProduceOperation v_index = r.choice(self.intvars) if not (0 <= v_index.value < length): v_index = ConstInt(r.random_integer() % length) return v_index