Python jtransform.Transformer类代码示例

def test_jit_merge_point_1():
    class FakeJitDriverSD:
        index = 42
        class jitdriver:
            active = True
            greens = ['green1', 'green2', 'voidgreen3']
            reds = ['red1', 'red2', 'voidred3']
    jd = FakeJitDriverSD()
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    vvoid1 = varoftype(lltype.Void)
    v3 = varoftype(lltype.Signed)
    v4 = varoftype(lltype.Signed)
    vvoid2 = varoftype(lltype.Void)
    v5 = varoftype(lltype.Void)
    op = SpaceOperation('jit_marker',
                        [Constant('jit_merge_point', lltype.Void),
                         Constant(jd.jitdriver, lltype.Void),
                         v1, v2, vvoid1, v3, v4, vvoid2], v5)
    tr = Transformer()
    tr.portal_jd = jd
    oplist = tr.rewrite_operation(op)
    assert len(oplist) == 7
    assert oplist[0].opname == '-live-'
    assert oplist[1].opname == 'int_guard_value'
    assert oplist[1].args   == [v1]
    assert oplist[2].opname == '-live-'
    assert oplist[3].opname == 'int_guard_value'
    assert oplist[3].args   == [v2]
    assert oplist[4].opname == '-live-'
    assert oplist[5].opname == 'jit_merge_point'
    assert oplist[5].args[0].value == 42
    assert list(oplist[5].args[1]) == [v1, v2]
    assert list(oplist[5].args[4]) == [v3, v4]
    assert oplist[6].opname == '-live-'

def indirect_residual_call_test(argtypes, restype, expectedkind):
    # an indirect call that is residual in all cases is very similar to
    # a residual direct call
    op = get_direct_call_op(argtypes, restype)
    op.opname = 'indirect_call'
    op.args[0] = varoftype(op.args[0].concretetype)
    op.args.append(Constant(['somegraph1', 'somegraph2'], lltype.Void))
    tr = Transformer(FakeCPU(), FakeResidualIndirectCallControl())
    tr.graph = 'someinitialgraph'
    oplist = tr.rewrite_operation(op)
    op0, op1 = oplist
    reskind = getkind(restype)[0]
    assert op0.opname == 'residual_call_%s_%s' % (expectedkind, reskind)
    assert op0.result == op.result
    assert op0.args[0] == op.args[0]
    assert op0.args[1] == 'calldescr'
    assert len(op0.args) == 2 + len(expectedkind)
    for sublist, kind1 in zip(op0.args[2:], expectedkind):
        assert sublist.kind.startswith(kind1)
        assert list(sublist) == [v for v in op.args[1:]
                                 if getkind(v.concretetype)==sublist.kind]
    for v in op.args[1:]:
        kind = getkind(v.concretetype)
        assert kind == 'void' or kind[0] in expectedkind
    assert op1.opname == '-live-'
    assert op1.args == []

 def test_casts(self):
     self.do_check('cast_int_to_longlong', EffectInfo.OS_LLONG_FROM_INT,
                   [lltype.Signed], lltype.SignedLongLong)
     self.do_check('cast_uint_to_longlong', EffectInfo.OS_LLONG_FROM_UINT,
                   [lltype.Unsigned], lltype.SignedLongLong)
     self.do_check('truncate_longlong_to_int', EffectInfo.OS_LLONG_TO_INT,
                   [lltype.SignedLongLong], lltype.Signed)
     self.do_check('cast_float_to_longlong', EffectInfo.OS_LLONG_FROM_FLOAT,
                   [lltype.Float], lltype.SignedLongLong)
     self.do_check('cast_longlong_to_float', EffectInfo.OS_LLONG_TO_FLOAT,
                   [lltype.SignedLongLong], lltype.Float)
     for T1 in [lltype.SignedLongLong, lltype.UnsignedLongLong]:
         for T2 in [lltype.Signed, lltype.Unsigned]:
             self.do_check('cast_primitive', EffectInfo.OS_LLONG_TO_INT,
                           [T1], T2)
             self.do_check('force_cast', EffectInfo.OS_LLONG_TO_INT,
                           [T1], T2)
             if T2 == lltype.Signed:
                 expected = EffectInfo.OS_LLONG_FROM_INT
             else:
                 expected = EffectInfo.OS_LLONG_FROM_UINT
             self.do_check('cast_primitive', expected, [T2], T1)
             self.do_check('force_cast', expected, [T2], T1)
     #
     for T1 in [lltype.SignedLongLong, lltype.UnsignedLongLong]:
         for T2 in [lltype.SignedLongLong, lltype.UnsignedLongLong]:
             vlist = [varoftype(T1)]
             v_result = varoftype(T2)
             op = SpaceOperation('force_cast', vlist, v_result)
             tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
             op1 = tr.rewrite_operation(op)
             assert op1 is None

 def do_check(self, opname, oopspecindex, ARGS, RESULT):
     vlist = [varoftype(ARG) for ARG in ARGS]
     v_result = varoftype(RESULT)
     op = SpaceOperation(opname, vlist, v_result)
     tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
     op1 = tr.rewrite_operation(op)
     if isinstance(op1, list):
         [op1] = op1
     #
     def is_llf(TYPE):
         return (TYPE == lltype.SignedLongLong or
                 TYPE == lltype.UnsignedLongLong or
                 TYPE == lltype.Float)
     if is_llf(RESULT):
         assert op1.opname == 'residual_call_irf_f'
     else:
         assert op1.opname == 'residual_call_irf_i'
     gotindex = getattr(EffectInfo, 'OS_' + op1.args[0].value.upper())
     assert gotindex == oopspecindex
     assert op1.args[1] == 'calldescr-%d' % oopspecindex
     assert list(op1.args[2]) == [v for v in vlist
                                  if not is_llf(v.concretetype)]
     assert list(op1.args[3]) == []
     assert list(op1.args[4]) == [v for v in vlist
                                  if is_llf(v.concretetype)]
     assert op1.result == v_result

 def test_is_true(self):
     for opname, T in [('llong_is_true', lltype.SignedLongLong),
                       ('ullong_is_true', lltype.UnsignedLongLong)]:
         v = varoftype(T)
         v_result = varoftype(lltype.Bool)
         op = SpaceOperation(opname, [v], v_result)
         tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
         oplist = tr.rewrite_operation(op)
         assert len(oplist) == 2
         assert oplist[0].opname == 'residual_call_irf_f'
         assert oplist[0].args[0].value == 'llong_from_int'
         assert oplist[0].args[1] == 'calldescr-84'
         assert list(oplist[0].args[2]) == [const(0)]
         assert list(oplist[0].args[3]) == []
         assert list(oplist[0].args[4]) == []
         v_x = oplist[0].result
         assert isinstance(v_x, Variable)
         assert v_x.concretetype is T
         assert oplist[1].opname == 'residual_call_irf_i'
         assert oplist[1].args[0].value == 'llong_ne'
         assert oplist[1].args[1] == 'calldescr-76'
         assert list(oplist[1].args[2]) == []
         assert list(oplist[1].args[3]) == []
         assert list(oplist[1].args[4]) == [v, v_x]
         assert oplist[1].result == v_result

def test_unknown_operation():
    op = SpaceOperation('foobar', [], varoftype(lltype.Void))
    tr = Transformer()
    try:
        tr.rewrite_operation(op)
    except Exception, e:
        assert 'foobar' in str(e)

def builtin_test(oopspec_name, args, RESTYPE, expected):
    v_result = varoftype(RESTYPE)
    tr = Transformer(FakeCPU(), FakeCallControl())
    tr.immutable_arrays = {}
    tr.vable_array_vars = {}
    if '/' in oopspec_name:
        oopspec_name, property = oopspec_name.split('/')
        def force_flags(op):
            if property == 'NONNEG':   return True
            if property == 'NEG':      return False
            raise ValueError(property)
        tr._get_list_nonneg_canraise_flags = force_flags
    op = SpaceOperation('direct_call',
                        [Constant("myfunc", lltype.Void)] + args,
                        v_result)
    try:
        oplist = tr._handle_list_call(op, oopspec_name, args)
    except NotSupported:
        assert expected is NotSupported
    else:
        assert expected is not NotSupported
        assert oplist is not None
        flattener = GraphFlattener(None, fake_regallocs())
        if not isinstance(oplist, list):
            oplist = [oplist]
        for op1 in oplist:
            flattener.serialize_op(op1)
        assert_format(flattener.ssarepr, expected)

def test_int_abs():
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    op = SpaceOperation('int_abs', [v1], v2)
    tr = Transformer(FakeCPU(), FakeRegularCallControl())
    tr.graph = "somemaingraph"
    oplist = tr.rewrite_operation(op)
    assert oplist[0].opname == 'inline_call_ir_i'
    assert oplist[0].args[0] == 'somejitcode'

def test_raw_malloc_fixedsize():
    S = lltype.Struct('dummy', ('x', lltype.Signed))
    v = varoftype(lltype.Ptr(S))
    flags = Constant({'flavor': 'raw', 'zero': True}, lltype.Void)
    op = SpaceOperation('malloc', [Constant(S, lltype.Void), flags], v)
    tr = Transformer(FakeCPU(), FakeResidualCallControl())
    op0, op1 = tr.rewrite_operation(op)
    assert op0.opname == 'residual_call_r_i'
    assert op0.args[0].value == 'raw_malloc_fixedsize_zero' #pseudo-fn as a str
    assert op1.opname == '-live-'
    assert op1.args == []

def test_raw_malloc_zero():
    S = rffi.CArray(lltype.Signed)
    v1 = varoftype(lltype.Signed)
    v = varoftype(lltype.Ptr(S))
    flags = Constant({'flavor': 'raw', 'zero': True}, lltype.Void)
    op = SpaceOperation('malloc_varsize', [Constant(S, lltype.Void), flags,
                                           v1], v)
    tr = Transformer(FakeCPU(), FakeResidualCallControl())
    op0, op1 = tr.rewrite_operation(op)
    assert op0.opname == 'residual_call_ir_i'
    assert op0.args[0].value == 'raw_malloc_varsize_zero'  # pseudo-fn as a str
    assert op1.opname == '-live-'
    assert op1.args == []

 def test_constants(self):
     for TYPE in [lltype.SignedLongLong, lltype.UnsignedLongLong]:
         v_x = varoftype(TYPE)
         vlist = [v_x, const(rffi.cast(TYPE, 7))]
         v_result = varoftype(TYPE)
         op = SpaceOperation('llong_add', vlist, v_result)
         tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
         op1 = tr.rewrite_operation(op)
         #
         assert op1.opname == 'residual_call_irf_f'
         assert list(op1.args[2]) == []
         assert list(op1.args[3]) == []
         assert list(op1.args[4]) == vlist
         assert op1.result == v_result

def test_raw_free():
    S = lltype.Struct('dummy', ('x', lltype.Signed))
    for flag in [True, False]:
        flags = Constant({'flavor': 'raw', 'track_allocation': flag},
                         lltype.Void)
        op = SpaceOperation('free', [varoftype(lltype.Ptr(S)), flags],
                            varoftype(lltype.Void))
        tr = Transformer(FakeCPU(), FakeResidualCallControl())
        op0, op1 = tr.rewrite_operation(op)
        assert op0.opname == 'residual_call_ir_v'
        if flag:
            pseudo_op_name = 'raw_free'
        else:
            pseudo_op_name = 'raw_free_no_track_allocation'
        assert op0.args[0].value == pseudo_op_name   # pseudo-function as a str
        assert op1.opname == '-live-'

def test_str2unicode():
    # test that the oopspec is present and correctly transformed
    PSTR = lltype.Ptr(rstr.STR)
    PUNICODE = lltype.Ptr(rstr.UNICODE)
    FUNC = lltype.FuncType([PSTR], PUNICODE)
    func = lltype.functionptr(FUNC, 'll_str2unicode',
                            _callable=rstr.LLHelpers.ll_str2unicode)
    v1 = varoftype(PSTR)
    v2 = varoftype(PUNICODE)
    op = SpaceOperation('direct_call', [const(func), v1], v2)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_r_r'
    assert op1.args[0].value == func
    assert op1.args[1] == 'calldescr-%d' % effectinfo.EffectInfo.OS_STR2UNICODE
    assert op1.args[2] == ListOfKind('ref', [v1])
    assert op1.result == v2

def test_quasi_immutable_setfield():
    from pypy.rpython.rclass import FieldListAccessor, IR_QUASIIMMUTABLE
    accessor = FieldListAccessor()
    accessor.initialize(None, {'inst_x': IR_QUASIIMMUTABLE})
    v1 = varoftype(lltype.Signed)
    STRUCT = lltype.GcStruct('struct', ('inst_x', lltype.Signed),
                             ('mutate_x', rclass.OBJECTPTR),
                             hints={'immutable_fields': accessor})
    for v_x in [const(lltype.malloc(STRUCT)), varoftype(lltype.Ptr(STRUCT))]:
        op = SpaceOperation('jit_force_quasi_immutable',
                            [v_x, Constant('mutate_x', lltype.Void)],
                            varoftype(lltype.Void))
        tr = Transformer(FakeCPU(), FakeRegularCallControl())
        tr.graph = 'currentgraph'
        op0, op1 = tr.rewrite_operation(op)
        assert op0.opname == '-live-'
        assert op1.opname == 'jit_force_quasi_immutable'
        assert op1.args[0] == v_x
        assert op1.args[1] == ('fielddescr', STRUCT, 'mutate_x')

def test_str_slice():
    # test that the oopspec is present and correctly transformed
    PSTR = lltype.Ptr(rstr.STR)
    INT = lltype.Signed
    FUNC = lltype.FuncType([PSTR, INT, INT], PSTR)
    func = lltype.functionptr(FUNC, '_ll_stringslice',
                            _callable=rstr.LLHelpers._ll_stringslice)
    v1 = varoftype(PSTR)
    v2 = varoftype(INT)
    v3 = varoftype(INT)
    v4 = varoftype(PSTR)
    op = SpaceOperation('direct_call', [const(func), v1, v2, v3], v4)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_ir_r'
    assert op1.args[0].value == func
    assert op1.args[1] == 'calldescr-%d' % effectinfo.EffectInfo.OS_STR_SLICE
    assert op1.args[2] == ListOfKind('int', [v2, v3])
    assert op1.args[3] == ListOfKind('ref', [v1])
    assert op1.result == v4