def test_location(self):
        def get_printable_location(n):
            return 'GREEN IS %d.' % n
        myjitdriver = JitDriver(greens=['n'], reds=['m'],
                                get_printable_location=get_printable_location)
        def f(n, m):
            while m > 0:
                myjitdriver.can_enter_jit(n=n, m=m)
                myjitdriver.jit_merge_point(n=n, m=m)
                m -= 1

        self.meta_interp(f, [123, 10])
        assert len(get_stats().locations) >= 4
        for loc in get_stats().locations:
            assert loc == (0, 123)

 def test_loop(self):
     myjitdriver = JitDriver(greens = [], reds = ['x', 'y', 'res'])
     def f(x, y):
         res = 0
         while y > 0:
             myjitdriver.can_enter_jit(x=x, y=y, res=res)
             myjitdriver.jit_merge_point(x=x, y=y, res=res)
             res += x
             y -= 1
         return res
     res = self.meta_interp(f, [6, 7])
     assert res == 42
     self.check_loop_count(1)
     self.check_loops({'guard_true': 1,
                       'int_add': 1, 'int_sub': 1, 'int_gt': 1,
                       'jump': 1})
     if self.basic:
         found = 0
         for op in get_stats().loops[0]._all_operations():
             if op.getopname() == 'guard_true':
                 liveboxes = op.fail_args
                 assert len(liveboxes) == 3
                 for box in liveboxes:
                     assert isinstance(box, history.BoxInt)
                 found += 1
         assert found == 1

    def test_list_simple_1(self):
        myjitdriver = JitDriver(greens=["foo"], reds=["x", "total"])

        class Foo:
            _immutable_fields_ = ["lst?[*]"]

            def __init__(self, lst):
                self.lst = lst

        def f(a, x):
            lst1 = [0, 0]
            lst1[1] = a
            foo = Foo(lst1)
            total = 0
            while x > 0:
                myjitdriver.jit_merge_point(foo=foo, x=x, total=total)
                # read a quasi-immutable field out of a Constant
                total += foo.lst[1]
                x -= 1
            return total

        #
        res = self.meta_interp(f, [100, 7])
        assert res == 700
        self.check_resops(getarrayitem_gc_pure=0, guard_not_invalidated=2, getarrayitem_gc=0, getfield_gc=0)
        #
        from pypy.jit.metainterp.warmspot import get_stats

        loops = get_stats().loops
        for loop in loops:
            assert len(loop.quasi_immutable_deps) == 1
            assert isinstance(loop.quasi_immutable_deps.keys()[0], QuasiImmut)

 def check_loop_count(self, count):
     """NB. This is a hack; use check_tree_loop_count() or
     check_enter_count() for the real thing.
     This counts as 1 every bridge in addition to every loop; and it does
     not count at all the entry bridges from interpreter, although they
     are TreeLoops as well."""
     assert get_stats().compiled_count == count

    def test_list_length_1(self):
        myjitdriver = JitDriver(greens=['foo'], reds=['x', 'total'])

        class Foo:
            _immutable_fields_ = ['lst?[*]']

            def __init__(self, lst):
                self.lst = lst

        class A:
            pass

        def f(a, x):
            lst1 = [0, 0]
            lst1[1] = a
            foo = Foo(lst1)
            total = 0
            while x > 0:
                myjitdriver.jit_merge_point(foo=foo, x=x, total=total)
                # make it a Constant after optimization only
                a = A()
                a.foo = foo
                foo = a.foo
                # read a quasi-immutable field out of it
                total += foo.lst[1]
                # also read the length
                total += len(foo.lst)
                x -= 1
            return total

        #
        res = self.meta_interp(f, [100, 7])
        assert res == 714
        self.check_loops(
            guard_not_invalidated=2,
            getfield_gc=0,
            getarrayitem_gc=0,
            getarrayitem_gc_pure=0,
            arraylen_gc=0,
            everywhere=True)
        #
        from pypy.jit.metainterp.warmspot import get_stats
        loops = get_stats().loops
        for loop in loops:
            assert len(loop.quasi_immutable_deps) == 1
            assert isinstance(loop.quasi_immutable_deps.keys()[0], QuasiImmut)

 def test_interp_single_loop(self):
     myjitdriver = JitDriver(greens = ['i'], reds = ['x', 'y'])
     bytecode = "abcd"
     def f(x, y):
         i = 0
         while i < len(bytecode):
             myjitdriver.jit_merge_point(i=i, x=x, y=y)
             op = bytecode[i]
             if op == 'a':
                 x += y
             elif op == 'b':
                 y -= 1
             elif op == 'c':
                 if y:
                     i = 0
                     myjitdriver.can_enter_jit(i=i, x=x, y=y)
                     continue
             else:
                 x += 1
             i += 1
         return x
     res = self.meta_interp(f, [5, 8])
     assert res == 42
     self.check_trace_count(1)
     # the 'int_eq' and following 'guard' should be constant-folded
     if 'unroll' in self.enable_opts:
         self.check_resops(int_eq=0, guard_true=2, guard_false=0)
     else:
         self.check_resops(int_eq=0, guard_true=1, guard_false=0)
     if self.basic:
         found = 0
         for op in get_stats().loops[0]._all_operations():
             if op.getopname() == 'guard_true':
                 liveboxes = op.getfailargs()
                 assert len(liveboxes) == 2     # x, y (in some order)
                 assert isinstance(liveboxes[0], history.BoxInt)
                 assert isinstance(liveboxes[1], history.BoxInt)
                 found += 1
         if 'unroll' in self.enable_opts:
             assert found == 2
         else:
             assert found == 1

    def test_call_assembler_keep_alive(self):
        myjitdriver1 = JitDriver(greens=['m'], reds=['n'])
        myjitdriver2 = JitDriver(greens=['m'], reds=['n', 'rec'])
        def h(m, n):
            while True:
                myjitdriver1.can_enter_jit(n=n, m=m)
                myjitdriver1.jit_merge_point(n=n, m=m)
                n = n >> 1
                if n == 0:
                    return 21
        def g(m, rec):
            n = 5
            while n > 0:
                myjitdriver2.can_enter_jit(n=n, m=m, rec=rec)
                myjitdriver2.jit_merge_point(n=n, m=m, rec=rec)
                if rec:
                    h(m, rec)
                n = n - 1
            return 21
        def f(u):
            for i in range(8):
                h(u, 32)  # make a loop and an exit bridge for h(u)
            g(u, 8)       # make a loop for g(u) with a call_assembler
            g(u, 0); g(u+1, 0)     # \
            g(u, 0); g(u+2, 0)     #  \  make more loops for g(u+1) to g(u+4),
            g(u, 0); g(u+3, 0)     #  /  but keeps g(u) alive
            g(u, 0); g(u+4, 0)     # /
            g(u, 8)       # call g(u) again, with its call_assembler to h(u)
            return 42

        res = self.meta_interp(f, [1], loop_longevity=4, inline=True)
        assert res == 42
        self.check_jitcell_token_count(6)
        tokens = [t() for t in get_stats().jitcell_token_wrefs]
        # Some loops have been freed
        assert None in tokens
        # Loop with number 0, h(), has not been freed
        assert 0 in [t.number for t in tokens if t]

 def check_aborted_count_at_least(self, count):
     assert get_stats().aborted_count >= count

 def check_history(self, expected=None, **isns):
     # this can be used after calling meta_interp
     get_stats().check_history(expected, **isns)

 def check_jumps(self, maxcount):
     assert get_stats().exec_jumps <= maxcount

 def check_aborted_count(self, count):
     assert get_stats().aborted_count == count

 def check_enter_count(self, count):
     assert get_stats().enter_count == count

 def check_enter_count_at_most(self, count):
     assert get_stats().enter_count <= count

 def check_tree_loop_count(self, count):
     assert len(get_stats().loops) == count

 def check_loop_count_at_most(self, count):
     assert get_stats().compiled_count <= count

 def check_target_token_count(self, count):
     tokens = get_stats().get_all_jitcell_tokens()
     n = sum ([len(t.target_tokens) for t in tokens])
     assert n == count

 def check_loops(self, expected=None, everywhere=False, **check):
     get_stats().check_loops(expected=expected, everywhere=everywhere,
                             **check)

 def check_jitcell_token_count(self, count): # was check_tree_loop_count
     assert len(get_stats().jitcell_token_wrefs) == count

 def check_max_trace_length(self, length):
     for loop in get_stats().loops:
         assert len(loop.operations) <= length + 5 # because we only check once per metainterp bytecode
         for op in loop.operations:
             if op.is_guard() and hasattr(op.getdescr(), '_debug_suboperations'):
                 assert len(op.getdescr()._debug_suboperations) <= length + 5

 def check_jumps(self, maxcount):
     return # FIXME
     assert get_stats().exec_jumps <= maxcount