import py
import random
from itertools import product

from rpython.flowspace.model import FunctionGraph, Block, Link, c_last_exception
from rpython.flowspace.model import SpaceOperation, Variable, Constant
from rpython.rtyper.lltypesystem import lltype, llmemory, rstr, rffi
from rpython.rtyper import rclass
from rpython.rtyper.lltypesystem.module import ll_math
from rpython.translator.unsimplify import varoftype
from rpython.jit.codewriter import heaptracker, effectinfo
from rpython.jit.codewriter.flatten import ListOfKind
from rpython.jit.codewriter.jtransform import Transformer, UnsupportedMallocFlags
from rpython.jit.metainterp.history import getkind

def const(x):
    return Constant(x, lltype.typeOf(x))

class FakeRTyper:
    instance_reprs = {}

class FakeCPU:
    class tracker:
        pass

    rtyper = FakeRTyper()
    def calldescrof(self, FUNC, ARGS, RESULT):
        return ('calldescr', FUNC, ARGS, RESULT)
    def fielddescrof(self, STRUCT, name):
        return ('fielddescr', STRUCT, name)
    def interiorfielddescrof(self, ARRAY, name):
        return ('interiorfielddescr', ARRAY, name)
    def arraydescrof(self, ARRAY):
        return FakeDescr(('arraydescr', ARRAY))
    def sizeof(self, STRUCT, vtable=None):
        return FakeDescr(('sizedescr', STRUCT))

class FakeDescr(tuple):
    pass

class FakeLink:
    args = []
    def __init__(self, exitcase):
        self.exitcase = self.llexitcase = exitcase

class FakeResidualCallControl:
    def guess_call_kind(self, op):
        return 'residual'
    def getcalldescr(self, op, oopspecindex=None, extraeffect=None,
                     extradescr=None):
        return 'calldescr'
    def calldescr_canraise(self, calldescr):
        return True

class FakeRegularCallControl:
    def guess_call_kind(self, op):
        return 'regular'
    def graphs_from(self, op):
        return ['somegraph']
    def get_jitcode(self, graph, called_from=None):
        assert graph == 'somegraph'
        return 'somejitcode'

class FakeResidualIndirectCallControl:
    def guess_call_kind(self, op):
        return 'residual'
    def getcalldescr(self, op, **kwds):
        return 'calldescr'
    def calldescr_canraise(self, calldescr):
        return True

class FakeRegularIndirectCallControl:
    def guess_call_kind(self, op):
        return 'regular'
    def graphs_from(self, op):
        return ['somegraph1', 'somegraph2']
    def getcalldescr(self, op, **kwds):
        return 'calldescr'
    def get_jitcode(self, graph, called_from=None):
        assert graph in ('somegraph1', 'somegraph2')
        return 'somejitcode' + graph[-1]
    def calldescr_canraise(self, calldescr):
        return False

class FakeCallInfoCollection:
    def __init__(self):
        self.seen = []
    def add(self, oopspecindex, calldescr, func):
        self.seen.append((oopspecindex, calldescr, func))
    def has_oopspec(self, oopspecindex):
        for i, c, f in self.seen:
            if i == oopspecindex:
                return True
        return False
    def callinfo_for_oopspec(self, oopspecindex):
        assert oopspecindex == effectinfo.EffectInfo.OS_STREQ_NONNULL
        class c:
            class adr:
                ptr = 1
        return ('calldescr', c)

class FakeBuiltinCallControl:
    def __init__(self):
        self.callinfocollection = FakeCallInfoCollection()
    def guess_call_kind(self, op):
        return 'builtin'
    def getcalldescr(self, op, oopspecindex=None, extraeffect=None,
                     extradescr=None):
        assert oopspecindex is not None    # in this test
        EI = effectinfo.EffectInfo
        if oopspecindex != EI.OS_ARRAYCOPY:
            PSTR = lltype.Ptr(rstr.STR)
            PUNICODE = lltype.Ptr(rstr.UNICODE)
            INT = lltype.Signed
            UNICHAR = lltype.UniChar
            FLOAT = lltype.Float
            ARRAYPTR = rffi.CArrayPtr(lltype.Char)
            argtypes = {
             EI.OS_MATH_SQRT:  ([FLOAT], FLOAT),
             EI.OS_STR2UNICODE:([PSTR], PUNICODE),
             EI.OS_STR_CONCAT: ([PSTR, PSTR], PSTR),
             EI.OS_STR_SLICE:  ([PSTR, INT, INT], PSTR),
             EI.OS_STREQ_NONNULL:  ([PSTR, PSTR], INT),
             EI.OS_UNI_CONCAT: ([PUNICODE, PUNICODE], PUNICODE),
             EI.OS_UNI_SLICE:  ([PUNICODE, INT, INT], PUNICODE),
             EI.OS_UNI_EQUAL:  ([PUNICODE, PUNICODE], lltype.Bool),
             EI.OS_UNIEQ_SLICE_CHECKNULL:([PUNICODE, INT, INT, PUNICODE], INT),
             EI.OS_UNIEQ_SLICE_NONNULL:  ([PUNICODE, INT, INT, PUNICODE], INT),
             EI.OS_UNIEQ_SLICE_CHAR:     ([PUNICODE, INT, INT, UNICHAR], INT),
             EI.OS_UNIEQ_NONNULL:        ([PUNICODE, PUNICODE], INT),
             EI.OS_UNIEQ_NONNULL_CHAR:   ([PUNICODE, UNICHAR], INT),
             EI.OS_UNIEQ_CHECKNULL_CHAR: ([PUNICODE, UNICHAR], INT),
             EI.OS_UNIEQ_LENGTHOK:       ([PUNICODE, PUNICODE], INT),
             EI.OS_RAW_MALLOC_VARSIZE_CHAR: ([INT], ARRAYPTR),
             EI.OS_RAW_FREE:             ([ARRAYPTR], lltype.Void),
             EI.OS_THREADLOCALREF_GET:   ([INT], INT),   # for example
             EI.OS_INT_PY_DIV: ([INT, INT], INT),
             EI.OS_INT_UDIV:   ([INT, INT], INT),
             EI.OS_INT_PY_MOD: ([INT, INT], INT),
             EI.OS_INT_UMOD:   ([INT, INT], INT),
            }
            argtypes = argtypes[oopspecindex]
            assert argtypes[0] == [v.concretetype for v in op.args[1:]]
            assert argtypes[1] == op.result.concretetype
            if oopspecindex == EI.OS_STR2UNICODE:
                assert extraeffect == EI.EF_ELIDABLE_CAN_RAISE
            elif oopspecindex == EI.OS_RAW_MALLOC_VARSIZE_CHAR:
                assert extraeffect == EI.EF_CAN_RAISE
            elif oopspecindex == EI.OS_RAW_FREE:
                assert extraeffect == EI.EF_CANNOT_RAISE
            elif oopspecindex == EI.OS_THREADLOCALREF_GET:
                assert extraeffect == self.expected_effect_of_threadlocalref_get
            elif oopspecindex in (EI.OS_STR_CONCAT, EI.OS_UNI_CONCAT,
                                  EI.OS_STR_SLICE, EI.OS_UNI_SLICE):
                assert extraeffect == EI.EF_ELIDABLE_OR_MEMORYERROR
            else:
                assert extraeffect == EI.EF_ELIDABLE_CANNOT_RAISE
        return 'calldescr-%d' % oopspecindex

    def calldescr_canraise(self, calldescr):
        EI = effectinfo.EffectInfo
        if calldescr == 'calldescr-%d' % EI.OS_RAW_MALLOC_VARSIZE_CHAR:
            return True
        return False


def test_optimize_goto_if_not():
    v1 = Variable()
    v2 = Variable()
    v3 = Variable(); v3.concretetype = lltype.Bool
    sp1 = SpaceOperation('foobar', [], None)
    sp2 = SpaceOperation('foobaz', [], None)
    block = Block([v1, v2])
    block.operations = [sp1, SpaceOperation('int_gt', [v1, v2], v3), sp2]
    block.exitswitch = v3
    block.exits = exits = [FakeLink(False), FakeLink(True)]
    res = Transformer().optimize_goto_if_not(block)
    assert res == True
    assert block.operations == [sp1, sp2]
    assert block.exitswitch == ('int_gt', v1, v2, '-live-before')
    assert block.exits == exits

def test_optimize_goto_if_not__incoming():
    v1 = Variable(); v1.concretetype = lltype.Bool
    block = Block([v1])
    block.exitswitch = v1
    block.exits = [FakeLink(False), FakeLink(True)]
    assert not Transformer().optimize_goto_if_not(block)

def test_optimize_goto_if_not__exit():
    # this case occurs in practice, e.g. with RPython code like:
    #     return bool(p) and p.somefield > 0
    v1 = Variable()
    v2 = Variable()
    v3 = Variable(); v3.concretetype = lltype.Bool
    block = Block([v1, v2])
    block.operations = [SpaceOperation('int_gt', [v1, v2], v3)]
    block.exitswitch = v3
    block.exits = exits = [FakeLink(False), FakeLink(True)]
    block.exits[1].args = [v3]
    res = Transformer().optimize_goto_if_not(block)
    assert res == True
    assert block.operations == []
    assert block.exitswitch == ('int_gt', v1, v2, '-live-before')
    assert block.exits == exits
    assert exits[1].args == [const(True)]

def test_optimize_goto_if_not__unknownop():
    v3 = Variable(); v3.concretetype = lltype.Bool
    block = Block([])
    block.operations = [SpaceOperation('foobar', [], v3)]
    block.exitswitch = v3
    block.exits = [FakeLink(False), FakeLink(True)]
    assert not Transformer().optimize_goto_if_not(block)

def test_optimize_goto_if_not__ptr_eq():
    for opname in ['ptr_eq', 'ptr_ne']:
        v1 = Variable()
        v2 = Variable()
        v3 = Variable(); v3.concretetype = lltype.Bool
        block = Block([v1, v2])
        block.operations = [SpaceOperation(opname, [v1, v2], v3)]
        block.exitswitch = v3
        block.exits = exits = [FakeLink(False), FakeLink(True)]
        res = Transformer().optimize_goto_if_not(block)
        assert res == True
        assert block.operations == []
        assert block.exitswitch == (opname, v1, v2, '-live-before')
        assert block.exits == exits

def test_optimize_goto_if_not__ptr_iszero():
    for opname in ['ptr_iszero', 'ptr_nonzero']:
        v1 = Variable()
        v3 = Variable(); v3.concretetype = lltype.Bool
        block = Block([v1])
        block.operations = [SpaceOperation(opname, [v1], v3)]
        block.exitswitch = v3
        block.exits = exits = [FakeLink(False), FakeLink(True)]
        res = Transformer().optimize_goto_if_not(block)
        assert res == True
        assert block.operations == []
        assert block.exitswitch == (opname, v1, '-live-before')
        assert block.exits == exits

def test_optimize_goto_if_not__argument_to_call():
    for opname in ['ptr_iszero', 'ptr_nonzero']:
        v1 = Variable()
        v3 = Variable(); v3.concretetype = lltype.Bool
        v4 = Variable()
        block = Block([v1])
        callop = SpaceOperation('residual_call_r_i',
                ["fake", ListOfKind('int', [v3])], v4)
        block.operations = [SpaceOperation(opname, [v1], v3), callop]
        block.exitswitch = v3
        block.exits = exits = [FakeLink(False), FakeLink(True)]
        res = Transformer().optimize_goto_if_not(block)
        assert not res

def test_symmetric():
    ops = {'int_add': 'int_add',
           'int_or': 'int_or',
           'int_gt': ('int_gt', 'int_lt'),
           'uint_eq': 'int_eq',
           'uint_le': ('uint_le', 'uint_ge'),
           'char_ne': 'int_ne',
           'char_lt': ('int_lt', 'int_gt'),
           'uint_xor': 'int_xor',
           'float_mul': 'float_mul',
           'float_gt': ('float_gt', 'float_lt'),
           }
    v3 = varoftype(lltype.Signed)
    for v1 in [varoftype(lltype.Signed), const(42)]:
        for v2 in [varoftype(lltype.Signed), const(43)]:
            for name1, name2 in ops.items():
                op = SpaceOperation(name1, [v1, v2], v3)
                op1 = Transformer(FakeCPU()).rewrite_operation(op)
                if isinstance(name2, str):
                    name2 = name2, name2
                if isinstance(v1, Constant) and isinstance(v2, Variable):
                    assert op1.args == [v2, v1]
                    assert op1.result == v3
                    assert op1.opname == name2[1]
                else:
                    assert op1.args == [v1, v2]
                    assert op1.result == v3
                    assert op1.opname == name2[0]

@py.test.mark.parametrize('opname', ['add_ovf', 'sub_ovf', 'mul_ovf'])
def test_int_op_ovf(opname):
    v3 = varoftype(lltype.Signed)
    for v1 in [varoftype(lltype.Signed), const(42)]:
        for v2 in [varoftype(lltype.Signed), const(43)]:
            op = SpaceOperation('int_' + opname, [v1, v2], v3)
            oplist = Transformer(FakeCPU()).rewrite_operation(op)
            op1, op0 = oplist
            assert op0.opname == 'int_' + opname
            if (isinstance(v1, Constant) and isinstance(v2, Variable)
                    and opname != 'sub_ovf'):
                assert op0.args == [v2, v1]
                assert op0.result == v3
            else:
                assert op0.args == [v1, v2]
                assert op0.result == v3
            assert op1.opname == '-live-'
            assert op1.args == []
            assert op1.result is None

def test_neg_ovf():
    v3 = varoftype(lltype.Signed)
    for v1 in [varoftype(lltype.Signed), const(42)]:
        op = SpaceOperation('direct_call', [Constant('neg_ovf'), v1], v3)
        oplist = Transformer(FakeCPU())._handle_int_special(op, 'int.neg_ovf',
                                                            [v1])
        op1, op0 = oplist
        assert op0.opname == 'int_sub_ovf'
        assert op0.args == [Constant(0), v1]
        assert op0.result == v3
        assert op1.opname == '-live-'
        assert op1.args == []
        assert op1.result is None

@py.test.mark.parametrize('opname', ['py_div', 'udiv', 'py_mod', 'umod'])
def test_int_op_residual(opname):
    v3 = varoftype(lltype.Signed)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    for v1 in [varoftype(lltype.Signed), const(42)]:
        for v2 in [varoftype(lltype.Signed), const(43)]:
            op = SpaceOperation('direct_call', [Constant(opname), v1, v2], v3)
            op0 = tr._handle_int_special(op, 'int.'+opname, [v1, v2])
            assert op0.opname == 'residual_call_ir_i'
            assert op0.args[0].value == opname  # pseudo-function as str
            expected = ('int_' + opname).upper()
            assert (op0.args[-1] == 'calldescr-%d' %
                     getattr(effectinfo.EffectInfo, 'OS_' + expected))

def test_calls():
    for RESTYPE, with_void, with_i, with_r, with_f in product(
        [lltype.Signed, rclass.OBJECTPTR, lltype.Float, lltype.Void],
        [False, True],
        [False, True],
        [False, True],
        [False, True],
    ):
        ARGS = []
        if with_void:
            ARGS += [lltype.Void, lltype.Void]
        if with_i:
            ARGS += [lltype.Signed, lltype.Char]
        if with_r:
            ARGS += [rclass.OBJECTPTR, lltype.Ptr(rstr.STR)]
        if with_f:
            ARGS += [lltype.Float, lltype.Float]
        random.shuffle(ARGS)
        if RESTYPE == lltype.Float:
            with_f = True
        if with_f:
            expectedkind = 'irf'   # all kinds
        elif with_i:
            expectedkind = 'ir'  # integers and references
        else:
            expectedkind = 'r'          # only references
        yield residual_call_test, ARGS, RESTYPE, expectedkind
        yield direct_call_test, ARGS, RESTYPE, expectedkind
        yield indirect_residual_call_test, ARGS, RESTYPE, expectedkind
        yield indirect_regular_call_test, ARGS, RESTYPE, expectedkind

def get_direct_call_op(argtypes, restype):
    FUNC = lltype.FuncType(argtypes, restype)
    fnptr = lltype.functionptr(FUNC, "g")    # no graph
    c_fnptr = const(fnptr)
    vars = [varoftype(TYPE) for TYPE in argtypes]
    v_result = varoftype(restype)
    op = SpaceOperation('direct_call', [c_fnptr] + vars, v_result)
    return op

def residual_call_test(argtypes, restype, expectedkind):
    op = get_direct_call_op(argtypes, restype)
    tr = Transformer(FakeCPU(), FakeResidualCallControl())
    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) == 1 + len(expectedkind) + 1
    for sublist, kind1 in zip(op0.args[1:-1], 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 direct_call_test(argtypes, restype, expectedkind):
    op = get_direct_call_op(argtypes, restype)
    tr = Transformer(FakeCPU(), FakeRegularCallControl())
    tr.graph = 'someinitialgraph'
    oplist = tr.rewrite_operation(op)
    op0, op1 = oplist
    reskind = getkind(restype)[0]
    assert op0.opname == 'inline_call_%s_%s' % (expectedkind, reskind)
    assert op0.result == op.result
    assert op0.args[0] == 'somejitcode'
    assert len(op0.args) == 1 + len(expectedkind)
    for sublist, kind1 in zip(op0.args[1:], 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 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) == 1 + len(expectedkind) + 1
    for sublist, kind1 in zip(op0.args[1:-1], 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 indirect_regular_call_test(argtypes, restype, expectedkind):
    # a regular indirect call is preceded by a guard_value on the
    # function address, so that pyjitpl can know which jitcode to follow
    from rpython.jit.codewriter.flatten import IndirectCallTargets
    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(), FakeRegularIndirectCallControl())
    tr.graph = 'someinitialgraph'
    oplist = tr.rewrite_operation(op)
    op0gv, op1gv, op0, op1 = oplist
    assert op0gv.opname == '-live-'
    assert op0gv.args == []
    assert op1gv.opname == 'int_guard_value'
    assert op1gv.args == [op.args[0]]
    assert op1gv.result is None
    #
    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 isinstance(op0.args[1], IndirectCallTargets)
    assert op0.args[1].lst == ['somejitcode1', 'somejitcode2']
    assert op0.args[-1] == 'calldescr'
    assert len(op0.args) == 2 + len(expectedkind) + 1
    for sublist, kind1 in zip(op0.args[2:-1], 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
    # Note: we still expect a -live- here, even though canraise() returns
    # False, because this 'residual_call' will likely call further jitcodes
    # which can do e.g. guard_class or other stuff requiring anyway a -live-.
    assert op1.opname == '-live-'
    assert op1.args == []

def test_getfield():
    # XXX a more compact encoding would be possible, something along
    # the lines of  getfield_gc_r %r0, $offset, %r1
    # which would not need a Descr at all.
    S1 = lltype.Struct('S1')
    S2 = lltype.GcStruct('S2')
    S  = lltype.GcStruct('S', ('int', lltype.Signed),
                              ('ps1', lltype.Ptr(S1)),
                              ('ps2', lltype.Ptr(S2)),
                              ('flt', lltype.Float),
                              ('boo', lltype.Bool),
                              ('chr', lltype.Char),
                              ('unc', lltype.UniChar))
    for name, suffix in [('int', 'i'),
                         ('ps1', 'i'),
                         ('ps2', 'r'),
                         ('flt', 'f'),
                         ('boo', 'i'),
                         ('chr', 'i'),
                         ('unc', 'i')]:
        v_parent = varoftype(lltype.Ptr(S))
        c_name = Constant(name, lltype.Void)
        v_result = varoftype(getattr(S, name))
        op = SpaceOperation('getfield', [v_parent, c_name], v_result)
        op1 = Transformer(FakeCPU()).rewrite_operation(op)
        assert op1.opname == 'getfield_gc_' + suffix
        fielddescr = ('fielddescr', S, name)
        assert op1.args == [v_parent, fielddescr]
        assert op1.result == v_result

def test_getfield_typeptr():
    v_parent = varoftype(rclass.OBJECTPTR)
    c_name = Constant('typeptr', lltype.Void)
    v_result = varoftype(rclass.OBJECT.typeptr)
    op = SpaceOperation('getfield', [v_parent, c_name], v_result)
    oplist = Transformer(FakeCPU()).rewrite_operation(op)
    op0, op1 = oplist
    assert op0.opname == '-live-'
    assert op0.args == []
    assert op1.opname == 'guard_class'
    assert op1.args == [v_parent]
    assert op1.result == v_result

def test_setfield():
    # XXX a more compact encoding would be possible; see test_getfield()
    S1 = lltype.Struct('S1')
    S2 = lltype.GcStruct('S2')
    S  = lltype.GcStruct('S', ('int', lltype.Signed),
                              ('ps1', lltype.Ptr(S1)),
                              ('ps2', lltype.Ptr(S2)),
                              ('flt', lltype.Float),
                              ('boo', lltype.Bool),
                              ('chr', lltype.Char),
                              ('unc', lltype.UniChar))
    for name, suffix in [('int', 'i'),
                         ('ps1', 'i'),
                         ('ps2', 'r'),
                         ('flt', 'f'),
                         ('boo', 'i'),
                         ('chr', 'i'),
                         ('unc', 'i')]:
        v_parent = varoftype(lltype.Ptr(S))
        c_name = Constant(name, lltype.Void)
        v_newvalue = varoftype(getattr(S, name))
        op = SpaceOperation('setfield', [v_parent, c_name, v_newvalue],
                            varoftype(lltype.Void))
        op1 = Transformer(FakeCPU()).rewrite_operation(op)
        assert op1.opname == 'setfield_gc_' + suffix
        fielddescr = ('fielddescr', S, name)
        assert op1.args == [v_parent, v_newvalue, fielddescr]
        assert op1.result is None

def test_malloc_new():
    S = lltype.GcStruct('S')
    v = varoftype(lltype.Ptr(S))
    op = SpaceOperation('malloc', [Constant(S, lltype.Void),
                                   Constant({'flavor': 'gc'}, lltype.Void)], v)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'new'
    assert op1.args == [('sizedescr', S)]

def test_malloc_new_zero_2():
    S = lltype.GcStruct('S', ('x', lltype.Signed))
    v = varoftype(lltype.Ptr(S))
    op = SpaceOperation('malloc', [Constant(S, lltype.Void),
                                   Constant({'flavor': 'gc',
                                             'zero': True}, lltype.Void)], v)
    op1, op2 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'new'
    assert op1.args == [('sizedescr', S)]
    assert op2.opname == 'setfield_gc_i'
    assert op2.args[0] == v

def test_malloc_new_zero_nested():
    S0 = lltype.GcStruct('S0')
    S = lltype.Struct('S', ('x', lltype.Ptr(S0)))
    S2 = lltype.GcStruct('S2', ('parent', S),
                         ('xx', lltype.Ptr(S0)))
    v = varoftype(lltype.Ptr(S2))
    op = SpaceOperation('malloc', [Constant(S2, lltype.Void),
                                   Constant({'flavor': 'gc',
                                             'zero': True}, lltype.Void)], v)
    op1, op2, op3 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'new'
    assert op1.args == [('sizedescr', S2)]
    assert op2.opname == 'setfield_gc_r'
    assert op2.args[0] == v
    assert op3.opname == 'setfield_gc_r'
    assert op3.args[0] == v

def test_malloc_new_with_vtable():
    vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
    S = lltype.GcStruct('S', ('parent', rclass.OBJECT))
    heaptracker.set_testing_vtable_for_gcstruct(S, vtable, 'S')
    v = varoftype(lltype.Ptr(S))
    op = SpaceOperation('malloc', [Constant(S, lltype.Void),
                                   Constant({'flavor': 'gc'}, lltype.Void)], v)
    cpu = FakeCPU()
    op1 = Transformer(cpu).rewrite_operation(op)
    assert op1.opname == 'new_with_vtable'
    assert op1.args == [('sizedescr', S)]

def test_malloc_new_with_destructor():
    vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
    S = lltype.GcStruct('S', ('parent', rclass.OBJECT), rtti=True)
    DESTRUCTOR = lltype.FuncType([lltype.Ptr(S)], lltype.Void)
    destructor = lltype.functionptr(DESTRUCTOR, 'destructor')
    lltype.attachRuntimeTypeInfo(S, destrptr=destructor)
    heaptracker.set_testing_vtable_for_gcstruct(S, vtable, 'S')
    v = varoftype(lltype.Ptr(S))
    op = SpaceOperation('malloc', [Constant(S, lltype.Void),
                                   Constant({'flavor': 'gc'}, lltype.Void)], v)
    tr = Transformer(FakeCPU(), FakeResidualCallControl())
    oplist = tr.rewrite_operation(op)
    op0, op1 = oplist
    assert op0.opname == 'residual_call_r_r'
    assert op0.args[0].value == 'alloc_with_del'    # pseudo-function as a str
    assert list(op0.args[1]) == []
    assert op1.opname == '-live-'
    assert op1.args == []

def test_raw_malloc():
    S = rffi.CArray(lltype.Char)
    v1 = varoftype(lltype.Signed)
    v = varoftype(lltype.Ptr(S))
    flags = Constant({'flavor': 'raw'}, lltype.Void)
    op = SpaceOperation('malloc_varsize', [Constant(S, lltype.Void), flags,
                                           v1], v)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op0, op1 = tr.rewrite_operation(op)
    assert op0.opname == 'residual_call_ir_i'
    assert op0.args[0].value == 'raw_malloc_varsize' # pseudo-function as a str
    assert (op0.args[-1] == 'calldescr-%d' %
            effectinfo.EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR)

    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_raw_malloc_unsupported_flag():
    S = rffi.CArray(lltype.Signed)
    v1 = varoftype(lltype.Signed)
    v = varoftype(lltype.Ptr(S))
    flags = Constant({'flavor': 'raw', 'unsupported_flag': True}, lltype.Void)
    op = SpaceOperation('malloc_varsize', [Constant(S, lltype.Void), flags,
                                           v1], v)
    tr = Transformer(FakeCPU(), FakeResidualCallControl())
    py.test.raises(UnsupportedMallocFlags, tr.rewrite_operation, op)

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_free():
    S = rffi.CArray(lltype.Char)
    flags = Constant({'flavor': 'raw', 'track_allocation': True},
                     lltype.Void)
    op = SpaceOperation('free', [varoftype(lltype.Ptr(S)), flags],
                        varoftype(lltype.Void))
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op0 = tr.rewrite_operation(op)
    assert op0.opname == 'residual_call_ir_v'
    assert op0.args[0].value == 'raw_free'
    assert op0.args[-1] == 'calldescr-%d' % effectinfo.EffectInfo.OS_RAW_FREE

def test_raw_free_no_track_allocation():
    S = rffi.CArray(lltype.Signed)
    flags = Constant({'flavor': 'raw', 'track_allocation': False},
                     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'
    assert op0.args[0].value == 'raw_free_no_track_allocation'
    assert op1.opname == '-live-'

def test_rename_on_links():
    v1 = Variable()
    v2 = Variable(); v2.concretetype = llmemory.Address
    v3 = Variable()
    block = Block([v1])
    block.operations = [SpaceOperation('cast_pointer', [v1], v2)]
    block2 = Block([v3])
    block.closeblock(Link([v2], block2))
    Transformer().optimize_block(block)
    assert block.inputargs == [v1]
    assert block.operations == []
    assert block.exits[0].target is block2
    assert block.exits[0].args == [v1]

def test_cast_ptr_to_adr():
    t = Transformer(FakeCPU(), None)
    v = varoftype(lltype.Ptr(lltype.Array()))
    v2 = varoftype(llmemory.Address)
    op1 = t.rewrite_operation(SpaceOperation('cast_ptr_to_adr', [v], v2))
    assert op1 is None

def test_int_eq():
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    v3 = varoftype(lltype.Bool)
    c0 = const(0)
    #
    for opname, reducedname in [('int_eq', 'int_is_zero'),
                                ('int_ne', 'int_is_true')]:
        op = SpaceOperation(opname, [v1, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == opname
        assert op1.args == [v1, v2]
        #
        op = SpaceOperation(opname, [v1, c0], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v1]
        #
        op = SpaceOperation(opname, [c0, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v2]

def test_ptr_eq():
    v1 = varoftype(lltype.Ptr(rstr.STR))
    v2 = varoftype(lltype.Ptr(rstr.STR))
    v3 = varoftype(lltype.Bool)
    c0 = const(lltype.nullptr(rstr.STR))
    #
    for opname, reducedname in [('ptr_eq', 'ptr_iszero'),
                                ('ptr_ne', 'ptr_nonzero')]:
        op = SpaceOperation(opname, [v1, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == opname
        assert op1.args == [v1, v2]
        #
        op = SpaceOperation(opname, [v1, c0], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v1]
        #
        op = SpaceOperation(opname, [c0, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v2]

def test_instance_ptr_eq():
    v1 = varoftype(rclass.OBJECTPTR)
    v2 = varoftype(rclass.OBJECTPTR)
    v3 = varoftype(lltype.Bool)
    c0 = const(lltype.nullptr(rclass.OBJECT))

    for opname, newopname, reducedname in [
        ('ptr_eq', 'instance_ptr_eq', 'ptr_iszero'),
        ('ptr_ne', 'instance_ptr_ne', 'ptr_nonzero')
    ]:
        op = SpaceOperation(opname, [v1, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == newopname
        assert op1.args == [v1, v2]

        op = SpaceOperation(opname, [v1, c0], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v1]

        op = SpaceOperation(opname, [c0, v1], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v1]

def test_nongc_ptr_eq():
    v1 = varoftype(rclass.NONGCOBJECTPTR)
    v2 = varoftype(rclass.NONGCOBJECTPTR)
    v3 = varoftype(lltype.Bool)
    c0 = const(lltype.nullptr(rclass.NONGCOBJECT))
    #
    for opname, reducedname in [('ptr_eq', 'int_is_zero'),
                                ('ptr_ne', 'int_is_true')]:
        op = SpaceOperation(opname, [v1, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == opname.replace('ptr_', 'int_')
        assert op1.args == [v1, v2]
        #
        op = SpaceOperation(opname, [v1, c0], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v1]
        #
        op = SpaceOperation(opname, [c0, v2], v3)
        op1 = Transformer().rewrite_operation(op)
        assert op1.opname == reducedname
        assert op1.args == [v2]
    #
    op = SpaceOperation('ptr_iszero', [v1], v3)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'int_is_zero'
    assert op1.args == [v1]
    #
    op = SpaceOperation('ptr_nonzero', [v1], v3)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'int_is_true'
    assert op1.args == [v1]

def test_str_getinteriorarraysize():
    v = varoftype(lltype.Ptr(rstr.STR))
    v_result = varoftype(lltype.Signed)
    op = SpaceOperation('getinteriorarraysize',
                        [v, Constant('chars', lltype.Void)],
                        v_result)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'strlen'
    assert op1.args == [v]
    assert op1.result == v_result

def test_unicode_getinteriorarraysize():
    v = varoftype(lltype.Ptr(rstr.UNICODE))
    v_result = varoftype(lltype.Signed)
    op = SpaceOperation('getinteriorarraysize',
                        [v, Constant('chars', lltype.Void)],
                        v_result)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'unicodelen'
    assert op1.args == [v]
    assert op1.result == v_result

def test_str_getinteriorfield():
    v = varoftype(lltype.Ptr(rstr.STR))
    v_index = varoftype(lltype.Signed)
    v_result = varoftype(lltype.Char)
    op = SpaceOperation('getinteriorfield',
                        [v, Constant('chars', lltype.Void), v_index],
                        v_result)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'strgetitem'
    assert op1.args == [v, v_index]
    assert op1.result == v_result

def test_unicode_getinteriorfield():
    v = varoftype(lltype.Ptr(rstr.UNICODE))
    v_index = varoftype(lltype.Signed)
    v_result = varoftype(lltype.UniChar)
    op = SpaceOperation('getinteriorfield',
                        [v, Constant('chars', lltype.Void), v_index],
                        v_result)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'unicodegetitem'
    assert op1.args == [v, v_index]
    assert op1.result == v_result

def test_dict_getinteriorfield():
    DICT = lltype.GcArray(lltype.Struct('ENTRY', ('v', lltype.Signed),
                                        ('k', lltype.Signed)))
    v = varoftype(lltype.Ptr(DICT))
    i = varoftype(lltype.Signed)
    v_result = varoftype(lltype.Signed)
    op = SpaceOperation('getinteriorfield', [v, i, Constant('v', lltype.Void)],
                        v_result)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'getinteriorfield_gc_i'
    assert op1.args == [v, i, ('interiorfielddescr', DICT, 'v')]
    op = SpaceOperation('getinteriorfield', [v, i, Constant('v', lltype.Void)],
                        Constant(None, lltype.Void))
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1 is None

def test_str_setinteriorfield():
    v = varoftype(lltype.Ptr(rstr.STR))
    v_index = varoftype(lltype.Signed)
    v_newchr = varoftype(lltype.Char)
    v_void = varoftype(lltype.Void)
    op = SpaceOperation('setinteriorfield',
                        [v, Constant('chars', lltype.Void), v_index, v_newchr],
                        v_void)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'strsetitem'
    assert op1.args == [v, v_index, v_newchr]
    assert op1.result == v_void

def test_unicode_setinteriorfield():
    v = varoftype(lltype.Ptr(rstr.UNICODE))
    v_index = varoftype(lltype.Signed)
    v_newchr = varoftype(lltype.UniChar)
    v_void = varoftype(lltype.Void)
    op = SpaceOperation('setinteriorfield',
                        [v, Constant('chars', lltype.Void), v_index, v_newchr],
                        v_void)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'unicodesetitem'
    assert op1.args == [v, v_index, v_newchr]
    assert op1.result == v_void

def test_dict_setinteriorfield():
    DICT = lltype.GcArray(lltype.Struct('ENTRY', ('v', lltype.Signed),
                                        ('k', lltype.Signed)))
    v = varoftype(lltype.Ptr(DICT))
    i = varoftype(lltype.Signed)
    v_void = varoftype(lltype.Void)
    op = SpaceOperation('setinteriorfield', [v, i, Constant('v', lltype.Void),
                                             i],
                        v_void)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'setinteriorfield_gc_i'
    assert op1.args == [v, i, i, ('interiorfielddescr', DICT, 'v')]
    op = SpaceOperation('setinteriorfield', [v, i, Constant('v', lltype.Void),
                                             v_void], v_void)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert not op1

def test_raw_store():
    v_storage = varoftype(llmemory.Address)
    v_index = varoftype(lltype.Signed)
    v_item = varoftype(lltype.Signed) # for example
    op = SpaceOperation('raw_store', [v_storage, v_index, v_item], None)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'raw_store_i'
    assert op1.args[0] == v_storage
    assert op1.args[1] == v_index
    assert op1.args[2] == v_item
    assert op1.args[3] == ('arraydescr', rffi.CArray(lltype.Signed))

def test_raw_load():
    v_storage = varoftype(llmemory.Address)
    v_index = varoftype(lltype.Signed)
    v_res = varoftype(lltype.Signed) # for example
    op = SpaceOperation('raw_load', [v_storage, v_index], v_res)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'raw_load_i'
    assert op1.args[0] == v_storage
    assert op1.args[1] == v_index
    assert op1.args[2] == ('arraydescr', rffi.CArray(lltype.Signed))
    assert op1.result == v_res

def test_promote_1():
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    op = SpaceOperation('hint',
                        [v1, Constant({'promote': True}, lltype.Void)],
                        v2)
    oplist = Transformer().rewrite_operation(op)
    op0, op1, op2 = oplist
    assert op0.opname == '-live-'
    assert op0.args == []
    assert op1.opname == 'int_guard_value'
    assert op1.args == [v1]
    assert op1.result is None
    assert op2 is None

def test_promote_2():
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    op = SpaceOperation('hint',
                        [v1, Constant({'promote': True}, lltype.Void)],
                        v2)
    returnblock = Block([varoftype(lltype.Signed)])
    returnblock.operations = ()
    block = Block([v1])
    block.operations = [op]
    block.closeblock(Link([v2], returnblock))
    Transformer().optimize_block(block)
    assert len(block.operations) == 2
    assert block.operations[0].opname == '-live-'
    assert block.operations[0].args == []
    assert block.operations[1].opname == 'int_guard_value'
    assert block.operations[1].args == [v1]
    assert block.operations[1].result is None
    assert block.exits[0].args == [v1]

def test_jit_merge_point_1():
    class FakeJitDriverSD:
        index = 42
        class jitdriver:
            active = True
            greens = ['green1', 'green2', 'voidgreen3']
            reds = ['red1', 'red2', 'voidred3']
            numreds = 3
    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 test_getfield_gc():
    S = lltype.GcStruct('S', ('x', lltype.Char))
    v1 = varoftype(lltype.Ptr(S))
    v2 = varoftype(lltype.Char)
    op = SpaceOperation('getfield', [v1, Constant('x', lltype.Void)], v2)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'getfield_gc_i'
    assert op1.args == [v1, ('fielddescr', S, 'x')]
    assert op1.result == v2

def test_getfield_gc_pure():
    S = lltype.GcStruct('S', ('x', lltype.Char),
                        hints={'immutable': True})
    v1 = varoftype(lltype.Ptr(S))
    v2 = varoftype(lltype.Char)
    op = SpaceOperation('getfield', [v1, Constant('x', lltype.Void)], v2)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'getfield_gc_i_pure'
    assert op1.args == [v1, ('fielddescr', S, 'x')]
    assert op1.result == v2

def test_getfield_gc_greenfield():
    class FakeCC:
        def get_vinfo(self, v):
            return None
        def could_be_green_field(self, S1, name1):
            assert S1 == S
            assert name1 == 'x'
            return True
    S = lltype.GcStruct('S', ('x', lltype.Char),
                        hints={'immutable': True})
    v1 = varoftype(lltype.Ptr(S))
    v2 = varoftype(lltype.Char)
    op = SpaceOperation('getfield', [v1, Constant('x', lltype.Void)], v2)
    op0, op1 = Transformer(FakeCPU(), FakeCC()).rewrite_operation(op)
    assert op0.opname == '-live-'
    assert op1.opname == 'getfield_gc_i_greenfield'
    assert op1.args == [v1, ('fielddescr', S, 'x')]
    assert op1.result == v2

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_str_newstr():
    c_STR = Constant(rstr.STR, lltype.Void)
    c_flavor = Constant({'flavor': 'gc'}, lltype.Void)
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Ptr(rstr.STR))
    op = SpaceOperation('malloc_varsize', [c_STR, c_flavor, v1], v2)
    op1 = Transformer().rewrite_operation(op)
    assert op1.opname == 'newstr'
    assert op1.args == [v1]
    assert op1.result == v2

def test_malloc_varsize_zero():
    c_A = Constant(lltype.GcArray(lltype.Signed), lltype.Void)
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(c_A.value)
    c_flags = Constant({"flavor": "gc", "zero": True}, lltype.Void)
    op = SpaceOperation('malloc_varsize', [c_A, c_flags, v1], v2)
    op1 = Transformer(FakeCPU()).rewrite_operation(op)
    assert op1.opname == 'new_array_clear'

def test_str_concat():
    # test that the oopspec is present and correctly transformed
    PSTR = lltype.Ptr(rstr.STR)
    FUNC = lltype.FuncType([PSTR, PSTR], PSTR)
    func = lltype.functionptr(FUNC, 'll_strconcat',
                              _callable=rstr.LLHelpers.ll_strconcat)
    v1 = varoftype(PSTR)
    v2 = varoftype(PSTR)
    v3 = varoftype(PSTR)
    op = SpaceOperation('direct_call', [const(func), v1, v2], v3)
    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] == ListOfKind('ref', [v1, v2])
    assert op1.args[2] == 'calldescr-%d' % effectinfo.EffectInfo.OS_STR_CONCAT
    assert op1.result == v3

def test_str_promote():
    PSTR = lltype.Ptr(rstr.STR)
    v1 = varoftype(PSTR)
    v2 = varoftype(PSTR)
    op = SpaceOperation('hint',
                        [v1, Constant({'promote_string': True}, lltype.Void)],
                        v2)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op0, op1, _ = tr.rewrite_operation(op)
    assert op1.opname == 'str_guard_value'
    assert op1.args[0] == v1
    assert op1.args[2] == 'calldescr'
    assert op1.result == v2
    assert op0.opname == '-live-'

def test_double_promote_str():
    PSTR = lltype.Ptr(rstr.STR)
    v1 = varoftype(PSTR)
    v2 = varoftype(PSTR)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = SpaceOperation('hint',
                         [v1, Constant({'promote_string': True}, lltype.Void)],
                         v2)
    op2 = SpaceOperation('hint',
                         [v1, Constant({'promote_string': True,
                                        'promote': True}, lltype.Void)],
                         v2)
    lst1 = tr.rewrite_operation(op1)
    lst2 = tr.rewrite_operation(op2)
    assert lst1 == lst2

def test_double_promote_nonstr():
    v1 = varoftype(lltype.Signed)
    v2 = varoftype(lltype.Signed)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = SpaceOperation('hint',
                         [v1, Constant({'promote': True}, lltype.Void)],
                         v2)
    op2 = SpaceOperation('hint',
                         [v1, Constant({'promote_string': True,
                                        'promote': True}, lltype.Void)],
                         v2)
    lst1 = tr.rewrite_operation(op1)
    lst2 = tr.rewrite_operation(op2)
    assert lst1 == lst2

def test_unicode_concat():
    # test that the oopspec is present and correctly transformed
    PSTR = lltype.Ptr(rstr.UNICODE)
    FUNC = lltype.FuncType([PSTR, PSTR], PSTR)
    func = lltype.functionptr(FUNC, 'll_strconcat',
                              _callable=rstr.LLHelpers.ll_strconcat)
    v1 = varoftype(PSTR)
    v2 = varoftype(PSTR)
    v3 = varoftype(PSTR)
    op = SpaceOperation('direct_call', [const(func), v1, v2], v3)
    cc = FakeBuiltinCallControl()
    tr = Transformer(FakeCPU(), cc)
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_r_r'
    assert op1.args[0].value == func
    assert op1.args[1] == ListOfKind('ref', [v1, v2])
    assert op1.args[2] == 'calldescr-%d' % effectinfo.EffectInfo.OS_UNI_CONCAT
    assert op1.result == v3
    #
    # check the callinfo_for_oopspec
    got = cc.callinfocollection.seen[0]
    assert got[0] == effectinfo.EffectInfo.OS_UNI_CONCAT
    assert got[1] == op1.args[2]    # the calldescr
    assert heaptracker.int2adr(got[2]) == llmemory.cast_ptr_to_adr(func)

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] == ListOfKind('int', [v2, v3])
    assert op1.args[2] == ListOfKind('ref', [v1])
    assert op1.args[3] == 'calldescr-%d' % effectinfo.EffectInfo.OS_STR_SLICE
    assert op1.result == v4

def test_unicode_slice():
    # test that the oopspec is present and correctly transformed
    PUNICODE = lltype.Ptr(rstr.UNICODE)
    INT = lltype.Signed
    FUNC = lltype.FuncType([PUNICODE, INT, INT], PUNICODE)
    func = lltype.functionptr(FUNC, '_ll_stringslice',
                            _callable=rstr.LLHelpers._ll_stringslice)
    v1 = varoftype(PUNICODE)
    v2 = varoftype(INT)
    v3 = varoftype(INT)
    v4 = varoftype(PUNICODE)
    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] == ListOfKind('int', [v2, v3])
    assert op1.args[2] == ListOfKind('ref', [v1])
    assert op1.args[3] == 'calldescr-%d' % effectinfo.EffectInfo.OS_UNI_SLICE
    assert op1.result == v4

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] == ListOfKind('ref', [v1])
    assert op1.args[2] == 'calldescr-%d' % effectinfo.EffectInfo.OS_STR2UNICODE
    assert op1.result == v2

def test_unicode_eq_checknull_char():
    # test that the oopspec is present and correctly transformed
    PUNICODE = lltype.Ptr(rstr.UNICODE)
    FUNC = lltype.FuncType([PUNICODE, PUNICODE], lltype.Bool)
    func = lltype.functionptr(FUNC, 'll_streq',
                              _callable=rstr.LLHelpers.ll_streq)
    v1 = varoftype(PUNICODE)
    v2 = varoftype(PUNICODE)
    v3 = varoftype(lltype.Bool)
    op = SpaceOperation('direct_call', [const(func), v1, v2], v3)
    cc = FakeBuiltinCallControl()
    tr = Transformer(FakeCPU(), cc)
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_r_i'
    assert op1.args[0].value == func
    assert op1.args[1] == ListOfKind('ref', [v1, v2])
    assert op1.args[2] == 'calldescr-%d' % effectinfo.EffectInfo.OS_UNI_EQUAL
    assert op1.result == v3
    # test that the OS_UNIEQ_* functions are registered
    cic = cc.callinfocollection
    assert cic.has_oopspec(effectinfo.EffectInfo.OS_UNIEQ_SLICE_NONNULL)
    assert cic.has_oopspec(effectinfo.EffectInfo.OS_UNIEQ_CHECKNULL_CHAR)

def test_list_ll_arraycopy():
    from rpython.rlib.rgc import ll_arraycopy
    LIST = lltype.GcArray(lltype.Signed)
    PLIST = lltype.Ptr(LIST)
    INT = lltype.Signed
    FUNC = lltype.FuncType([PLIST]*2+[INT]*3, lltype.Void)
    func = lltype.functionptr(FUNC, 'll_arraycopy', _callable=ll_arraycopy)
    v1 = varoftype(PLIST)
    v2 = varoftype(PLIST)
    v3 = varoftype(INT)
    v4 = varoftype(INT)
    v5 = varoftype(INT)
    v6 = varoftype(lltype.Void)
    op = SpaceOperation('direct_call', [const(func), v1, v2, v3, v4, v5], v6)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_ir_v'
    assert op1.args[0].value == func
    assert op1.args[1] == ListOfKind('int', [v3, v4, v5])
    assert op1.args[2] == ListOfKind('ref', [v1, v2])
    assert op1.args[3] == 'calldescr-%d' % effectinfo.EffectInfo.OS_ARRAYCOPY

def test_math_sqrt():
    # test that the oopspec is present and correctly transformed
    FLOAT = lltype.Float
    FUNC = lltype.FuncType([FLOAT], FLOAT)
    func = lltype.functionptr(FUNC, 'll_math',
                              _callable=ll_math.sqrt_nonneg)
    v1 = varoftype(FLOAT)
    v2 = varoftype(FLOAT)
    op = SpaceOperation('direct_call', [const(func), v1], v2)
    tr = Transformer(FakeCPU(), FakeBuiltinCallControl())
    op1 = tr.rewrite_operation(op)
    assert op1.opname == 'residual_call_irf_f'
    assert op1.args[0].value == func
    assert op1.args[1] == ListOfKind("int", [])
    assert op1.args[2] == ListOfKind("ref", [])
    assert op1.args[3] == ListOfKind('float', [v1])
    assert op1.args[4] == 'calldescr-%d' % effectinfo.EffectInfo.OS_MATH_SQRT
    assert op1.result == v2

def test_quasi_immutable():
    from rpython.rtyper.rclass import FieldListAccessor, IR_QUASIIMMUTABLE
    accessor = FieldListAccessor()
    accessor.initialize(None, {'inst_x': IR_QUASIIMMUTABLE})
    v2 = 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('getfield', [v_x, Constant('inst_x', lltype.Void)],
                            v2)
        tr = Transformer(FakeCPU())
        [_, op1, op2] = tr.rewrite_operation(op)
        assert op1.opname == 'record_quasiimmut_field'
        assert len(op1.args) == 3
        assert op1.args[0] == v_x
        assert op1.args[1] == ('fielddescr', STRUCT, 'inst_x')
        assert op1.args[2] == ('fielddescr', STRUCT, 'mutate_x')
        assert op1.result is None
        assert op2.opname == 'getfield_gc_i_pure'
        assert len(op2.args) == 2
        assert op2.args[0] == v_x
        assert op2.args[1] == ('fielddescr', STRUCT, 'inst_x')
        assert op2.result is op.result

def test_quasi_immutable_setfield():
    from rpython.rtyper.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_no_gcstruct_nesting_outside_of_OBJECT():
    PARENT = lltype.GcStruct('parent')
    STRUCT = lltype.GcStruct('struct', ('parent', PARENT),
                                       ('x', lltype.Signed))
    v_x = varoftype(lltype.Ptr(STRUCT))
    op = SpaceOperation('getfield', [v_x, Constant('x', lltype.Void)],
                        varoftype(lltype.Signed))
    tr = Transformer(None, None)
    py.test.raises(NotImplementedError, tr.rewrite_operation, op)

def test_no_fixedsizearray():
    A = lltype.FixedSizeArray(lltype.Signed, 5)
    v_x = varoftype(lltype.Ptr(A))
    op = SpaceOperation('getarrayitem', [v_x, Constant(0, lltype.Signed)],
                        varoftype(lltype.Signed))
    tr = Transformer(None, None)
    tr.graph = 'demo'
    py.test.raises(NotImplementedError, tr.rewrite_operation, op)
    op = SpaceOperation('setarrayitem', [v_x, Constant(0, lltype.Signed),
                                              Constant(42, lltype.Signed)],
                        varoftype(lltype.Void))
    e = py.test.raises(NotImplementedError, tr.rewrite_operation, op)
    assert str(e.value) == (
        "'demo' uses %r, which is not supported by the JIT codewriter" % (A,))

def _test_threadlocalref_get(loop_inv):
    from rpython.rlib.rthread import ThreadLocalField
    tlfield = ThreadLocalField(lltype.Signed, 'foobar_test_',
                               loop_invariant=loop_inv)
    OS_THREADLOCALREF_GET = effectinfo.EffectInfo.OS_THREADLOCALREF_GET
    c = const(tlfield.getoffset())
    v = varoftype(lltype.Signed)
    op = SpaceOperation('threadlocalref_get', [c], v)
    cc = FakeBuiltinCallControl()
    cc.expected_effect_of_threadlocalref_get = (
        effectinfo.EffectInfo.EF_LOOPINVARIANT if loop_inv
        else effectinfo.EffectInfo.EF_CANNOT_RAISE)
    tr = Transformer(FakeCPU(), cc)
    op0 = tr.rewrite_operation(op)
    assert op0.opname == 'residual_call_ir_i'
    assert op0.args[0].value == 'threadlocalref_get' # pseudo-function as str
    assert op0.args[1] == ListOfKind("int", [c])
    assert op0.args[2] == ListOfKind("ref", [])
    assert op0.args[3] == 'calldescr-%d' % OS_THREADLOCALREF_GET
    assert op0.result == v

def test_threadlocalref_get_no_loop_inv():
    _test_threadlocalref_get(loop_inv=False)

def test_threadlocalref_get_with_loop_inv():
    _test_threadlocalref_get(loop_inv=True)

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

def test_likely_unlikely():
    v1 = varoftype(lltype.Bool)
    v2 = varoftype(lltype.Bool)
    op = SpaceOperation('likely', [v1], v2)
    tr = Transformer()
    assert tr.rewrite_operation(op) is None
    op = SpaceOperation('unlikely', [v1], v2)
    assert tr.rewrite_operation(op) is None