[pypy-commit] stmgc default: shadowstack: improve the aliasing analysis in the C code.

[arigo]

Author: Armin Rigo <arigo at tunes.org>
Branch: 
Changeset: r1017:ddbc16971682
Date: 2014-03-15 11:11 +0100
http://bitbucket.org/pypy/stmgc/changeset/ddbc16971682/

Log:	shadowstack: improve the aliasing analysis in the C code.

diff --git a/c7/stm/core.h b/c7/stm/core.h
--- a/c7/stm/core.h
+++ b/c7/stm/core.h
@@ -150,7 +150,7 @@
 
     /* In case of abort, we restore the 'shadowstack' field and the
        'thread_local_obj' field. */
-    object_t **shadowstack_at_start_of_transaction;
+    struct stm_shadowentry_s *shadowstack_at_start_of_transaction;
     object_t *threadlocal_at_start_of_transaction;
 
     /* For debugging */
diff --git a/c7/stm/gcpage.c b/c7/stm/gcpage.c
--- a/c7/stm/gcpage.c
+++ b/c7/stm/gcpage.c
@@ -397,11 +397,11 @@
 
             if (must_be_zero == (segment_base == get_segment_base(0))) {
 
-                object_t **current = tl->shadowstack;
-                object_t **base = tl->shadowstack_base;
+                struct stm_shadowentry_s *current = tl->shadowstack;
+                struct stm_shadowentry_s *base = tl->shadowstack_base;
                 while (current-- != base) {
-                    assert(*current != (object_t *)-1);
-                    mark_visit_object(*current, segment_base);
+                    assert(current->ss != (object_t *)-1);
+                    mark_visit_object(current->ss, segment_base);
                 }
                 mark_visit_object(tl->thread_local_obj, segment_base);
             }
diff --git a/c7/stm/nursery.c b/c7/stm/nursery.c
--- a/c7/stm/nursery.c
+++ b/c7/stm/nursery.c
@@ -158,11 +158,11 @@
 static void collect_roots_in_nursery(void)
 {
     stm_thread_local_t *tl = STM_SEGMENT->running_thread;
-    object_t **current = tl->shadowstack;
-    object_t **base = tl->shadowstack_base;
+    struct stm_shadowentry_s *current = tl->shadowstack;
+    struct stm_shadowentry_s *base = tl->shadowstack_base;
     while (current-- != base) {
-        assert(*current != (object_t *)-1);
-        minor_trace_if_young(current);
+        assert(current->ss != (object_t *)-1);
+        minor_trace_if_young(&current->ss);
     }
     minor_trace_if_young(&tl->thread_local_obj);
 }
diff --git a/c7/stm/setup.c b/c7/stm/setup.c
--- a/c7/stm/setup.c
+++ b/c7/stm/setup.c
@@ -118,7 +118,8 @@
 
 void _init_shadow_stack(stm_thread_local_t *tl)
 {
-    object_t **s = (object_t **)malloc(SHADOW_STACK_SIZE * sizeof(object_t *));
+    struct stm_shadowentry_s *s = (struct stm_shadowentry_s *)
+        malloc(SHADOW_STACK_SIZE * sizeof(struct stm_shadowentry_s));
     assert(s);
     tl->shadowstack = s;
     tl->shadowstack_base = s;
diff --git a/c7/stmgc.h b/c7/stmgc.h
--- a/c7/stmgc.h
+++ b/c7/stmgc.h
@@ -48,9 +48,15 @@
 };
 #define STM_SEGMENT           ((stm_segment_info_t *)4352)
 
+struct stm_shadowentry_s {
+    /* Like stm_read_marker_s, this is a struct to enable better
+       aliasing analysis in the C code. */
+    object_t *ss;
+};
+
 typedef struct stm_thread_local_s {
     /* every thread should handle the shadow stack itself */
-    object_t **shadowstack, **shadowstack_base;
+    struct stm_shadowentry_s *shadowstack, *shadowstack_base;
     /* a generic optional thread-local object */
     object_t *thread_local_obj;
     /* in case this thread runs a transaction that aborts,
@@ -218,9 +224,9 @@
 
 /* Push and pop roots from/to the shadow stack. Only allowed inside
    transaction. */
-#define STM_PUSH_ROOT(tl, p)   (*((tl).shadowstack++) = (object_t *)(p))
-#define STM_POP_ROOT(tl, p)    ((p) = (typeof(p))*(--(tl).shadowstack))
-#define STM_POP_ROOT_RET(tl)   (*(--(tl).shadowstack))
+#define STM_PUSH_ROOT(tl, p)   ((tl).shadowstack++->ss = (object_t *)(p))
+#define STM_POP_ROOT(tl, p)    ((p) = (typeof(p))((--(tl).shadowstack)->ss))
+#define STM_POP_ROOT_RET(tl)   ((--(tl).shadowstack)->ss)
 
 
 /* Every thread needs to have a corresponding stm_thread_local_t
diff --git a/c7/test/support.py b/c7/test/support.py
--- a/c7/test/support.py
+++ b/c7/test/support.py
@@ -12,8 +12,12 @@
 #define _STM_FAST_ALLOC ...
 #define _STM_GCFLAG_WRITE_BARRIER ...
 
+struct stm_shadowentry_s {
+    object_t *ss;
+};
+
 typedef struct {
-    object_t **shadowstack, **shadowstack_base;
+    struct stm_shadowentry_s *shadowstack, *shadowstack_base;
     object_t *thread_local_obj;
     char *mem_clear_on_abort;
     size_t mem_bytes_to_clear_on_abort;
@@ -389,7 +393,7 @@
 
 def _allocate_thread_local():
     tl = ffi.new("stm_thread_local_t *")
-    ss = ffi.new("object_t *[]", SHADOWSTACK_LENGTH)
+    ss = ffi.new("struct stm_shadowentry_s[]", SHADOWSTACK_LENGTH)
     _keepalive[tl] = ss
     tl.shadowstack = ss
     tl.shadowstack_base = ss
@@ -462,7 +466,7 @@
         tl = self.tls[self.current_thread]
         curlength = tl.shadowstack - tl.shadowstack_base
         assert 0 <= curlength < SHADOWSTACK_LENGTH
-        tl.shadowstack[0] = ffi.cast("object_t *", o)
+        tl.shadowstack[0].ss = ffi.cast("object_t *", o)
         tl.shadowstack += 1
 
     def pop_root(self):
@@ -472,7 +476,7 @@
             raise EmptyStack
         assert 0 < curlength <= SHADOWSTACK_LENGTH
         tl.shadowstack -= 1
-        return ffi.cast("object_t *", tl.shadowstack[0])
+        return ffi.cast("object_t *", tl.shadowstack[0].ss)
 
     def push_root_no_gc(self):
         "Pushes an invalid object, to crash in case the GC is called"