Commits

Maciej Fijalkowski committed 904242f

remove old tests. In fact we need the frame_adjustment just after label, since
we can't jump to random places (and execute token takes care)

  • Participants
  • Parent commits fa418e5
  • Branches jitframe-on-heap

Comments (0)

Files changed (2)

File pypy/jit/backend/x86/assembler.py

         operations = regalloc.prepare_loop(inputargs, operations, looptoken,
                                            clt.allgcrefs)
         rgc._make_sure_does_not_move(clt.frame_info)
-        self._insert_frame_adjustment(clt.frame_info)
         looppos = self.mc.get_relative_pos()
         looptoken._x86_loop_code = looppos
         frame_depth = self._assemble(regalloc, inputargs, operations)
         return stack_check_cmp_ofs, ofs
 
     def _insert_frame_adjustment(self, frame_info):
+        # XXX note that this can be easily shifted to JUMP
+        #     instead of LABEL, would be slightly faster
         gcmap_ofs = self.cpu.get_ofs_of_frame_field('jf_gcmap')
         frame_info_addr = rffi.cast(lltype.Signed, frame_info)
         frame_info_ofs = self.cpu.get_ofs_of_frame_field('jf_frame_info')

File pypy/jit/backend/x86/test/test_gc_integration.py

         # this is a fairly CPU specific check
         all = len(gpr_reg_mgr_cls.all_regs)
         assert frame.jf_gcpattern == (1 << (all - 1)) | (1 << (all - 2))
+        # the gcmap should contain three things, p0, p1 and p3
+        assert len(frame.jf_gcmap) == 3
+        for i in range(3):
+            assert frame.jf_gcmap[i] == frame.jf_frame_info.jfi_gcmap[i]
+        xxx
 
     def test_rewrite_constptr(self):
         ops = '''
             s1ref = self.cpu.get_latest_value_ref(self.deadframe, i)
             s1 = lltype.cast_opaque_ptr(lltype.Ptr(S1), s1ref)
             assert s1 == getattr(s2, 's%d' % i)
-
-
-class MockShadowStackRootMap(MockGcRootMap):
-    is_shadow_stack = True
-    MARKER_FRAME = 88       # this marker follows the frame addr
-    S1 = lltype.GcStruct('S1')
-
-    def __init__(self):
-        self.addrs = lltype.malloc(rffi.CArray(lltype.Signed), 20,
-                                   flavor='raw')
-        # root_stack_top
-        self.addrs[0] = rffi.cast(lltype.Signed, self.addrs) + 3*WORD
-        # random stuff
-        self.addrs[1] = 123456
-        self.addrs[2] = 654321
-        self.check_initial_and_final_state()
-        self.callshapes = {}
-        self.should_see = []
-
-    def check_initial_and_final_state(self):
-        assert self.addrs[0] == rffi.cast(lltype.Signed, self.addrs) + 3*WORD
-        assert self.addrs[1] == 123456
-        assert self.addrs[2] == 654321
-
-    def get_root_stack_top_addr(self):
-        return rffi.cast(lltype.Signed, self.addrs)
-
-    def compress_callshape(self, shape, datablockwrapper):
-        assert shape[0] == 'shape'
-        return ['compressed'] + shape[1:]
-
-    def write_callshape(self, mark, force_index):
-        assert mark[0] == 'compressed'
-        assert force_index not in self.callshapes
-        assert force_index == 42 + len(self.callshapes)
-        self.callshapes[force_index] = mark
-
-    def hook_malloc_slowpath(self):
-        num_entries = self.addrs[0] - rffi.cast(lltype.Signed, self.addrs)
-        assert num_entries == 5*WORD    # 3 initially, plus 2 by the asm frame
-        assert self.addrs[1] == 123456  # unchanged
-        assert self.addrs[2] == 654321  # unchanged
-        frame_addr = self.addrs[3]                   # pushed by the asm frame
-        assert self.addrs[4] == self.MARKER_FRAME    # pushed by the asm frame
-        #
-        from pypy.jit.backend.x86.arch import FORCE_INDEX_OFS
-        addr = rffi.cast(rffi.CArrayPtr(lltype.Signed),
-                         frame_addr + FORCE_INDEX_OFS)
-        force_index = addr[0]
-        assert force_index == 43    # in this test: the 2nd call_malloc_nursery
-        #
-        # The callshapes[43] saved above should list addresses both in the
-        # COPY_AREA and in the "normal" stack, where all the 16 values p1-p16
-        # of test_save_regs_at_correct_place should have been stored.  Here
-        # we replace them with new addresses, to emulate a moving GC.
-        shape = self.callshapes[force_index]
-        assert len(shape[1:]) == len(self.should_see)
-        new_objects = [None] * len(self.should_see)
-        for ofs in shape[1:]:
-            assert isinstance(ofs, int)    # not a register at all here
-            addr = rffi.cast(rffi.CArrayPtr(lltype.Signed), frame_addr + ofs)
-            contains = addr[0]
-            for j in range(len(self.should_see)):
-                obj = self.should_see[j]
-                if contains == rffi.cast(lltype.Signed, obj):
-                    assert new_objects[j] is None   # duplicate?
-                    break
-            else:
-                assert 0   # the value read from the stack looks random?
-            new_objects[j] = lltype.malloc(self.S1)
-            addr[0] = rffi.cast(lltype.Signed, new_objects[j])
-        self.should_see[:] = new_objects
-
-
-class TestMallocShadowStack(BaseTestRegalloc):
-
-    def setup_method(self, method):
-        cpu = CPU(None, None)
-        cpu.gc_ll_descr = GCDescrFastpathMalloc()
-        cpu.gc_ll_descr.gcrootmap = MockShadowStackRootMap()
-        cpu.setup_once()
-        for i in range(42):
-            cpu.reserve_some_free_fail_descr_number()
-        self.cpu = cpu
-
-    def test_save_regs_at_correct_place(self):
-        cpu = self.cpu
-        gc_ll_descr = cpu.gc_ll_descr
-        S1 = gc_ll_descr.gcrootmap.S1
-        S2 = lltype.GcStruct('S2', ('s0', lltype.Ptr(S1)),
-                                   ('s1', lltype.Ptr(S1)),
-                                   ('s2', lltype.Ptr(S1)),
-                                   ('s3', lltype.Ptr(S1)),
-                                   ('s4', lltype.Ptr(S1)),
-                                   ('s5', lltype.Ptr(S1)),
-                                   ('s6', lltype.Ptr(S1)),
-                                   ('s7', lltype.Ptr(S1)),
-                                   ('s8', lltype.Ptr(S1)),
-                                   ('s9', lltype.Ptr(S1)),
-                                   ('s10', lltype.Ptr(S1)),
-                                   ('s11', lltype.Ptr(S1)),
-                                   ('s12', lltype.Ptr(S1)),
-                                   ('s13', lltype.Ptr(S1)),
-                                   ('s14', lltype.Ptr(S1)),
-                                   ('s15', lltype.Ptr(S1)))
-        self.namespace = self.namespace.copy()
-        for i in range(16):
-            self.namespace['ds%i' % i] = cpu.fielddescrof(S2, 's%d' % i)
-        ops = '''
-        [i0, p0]
-        p1 = getfield_gc(p0, descr=ds0)
-        p2 = getfield_gc(p0, descr=ds1)
-        p3 = getfield_gc(p0, descr=ds2)
-        p4 = getfield_gc(p0, descr=ds3)
-        p5 = getfield_gc(p0, descr=ds4)
-        p6 = getfield_gc(p0, descr=ds5)
-        p7 = getfield_gc(p0, descr=ds6)
-        p8 = getfield_gc(p0, descr=ds7)
-        p9 = getfield_gc(p0, descr=ds8)
-        p10 = getfield_gc(p0, descr=ds9)
-        p11 = getfield_gc(p0, descr=ds10)
-        p12 = getfield_gc(p0, descr=ds11)
-        p13 = getfield_gc(p0, descr=ds12)
-        p14 = getfield_gc(p0, descr=ds13)
-        p15 = getfield_gc(p0, descr=ds14)
-        p16 = getfield_gc(p0, descr=ds15)
-        #
-        # now all registers are in use
-        p17 = call_malloc_nursery(40)
-        p18 = call_malloc_nursery(40)     # overflow
-        #
-        guard_true(i0) [p1, p2, p3, p4, p5, p6, p7, p8,         \
-               p9, p10, p11, p12, p13, p14, p15, p16]
-        '''
-        s2 = lltype.malloc(S2)
-        for i in range(16):
-            s1 = lltype.malloc(S1)
-            setattr(s2, 's%d' % i, s1)
-            gc_ll_descr.gcrootmap.should_see.append(s1)
-        s2ref = lltype.cast_opaque_ptr(llmemory.GCREF, s2)
-        #
-        self.interpret(ops, [0, s2ref])
-        gc_ll_descr.check_nothing_in_nursery()
-        assert gc_ll_descr.calls == [40]
-        gc_ll_descr.gcrootmap.check_initial_and_final_state()
-        # check the returned pointers
-        for i in range(16):
-            s1ref = self.cpu.get_latest_value_ref(self.deadframe, i)
-            s1 = lltype.cast_opaque_ptr(lltype.Ptr(S1), s1ref)
-            for j in range(16):
-                assert s1 != getattr(s2, 's%d' % j)
-            assert s1 == gc_ll_descr.gcrootmap.should_see[i]