X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fthread.h;h=88b03bcb6ffc448b11565e37dd80a5efd787198a;hb=ed1910efb36f71b5ebe33b5ffffd7195e15644de;hp=f832c6be68c636b910a1e6f83172a0a8faaade00;hpb=7aef55b130d95c384b63422807f1848faa9aba5a;p=sbcl.git

diff --git a/src/runtime/thread.h b/src/runtime/thread.h
index f832c6b..88b03bc 100644
--- a/src/runtime/thread.h
+++ b/src/runtime/thread.h
@@ -69,7 +69,9 @@ extern struct threads_suspend_info suspend_info;
 
 struct gcing_safety {
     lispobj csp_around_foreign_call;
+#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
     lispobj* pc_around_foreign_call;
+#endif
 };
 
 int handle_safepoint_violation(os_context_t *context, os_vm_address_t addr);
@@ -102,41 +104,12 @@ union per_thread_data {
  */
 struct nonpointer_thread_data
 {
-#ifdef LISP_FEATURE_SB_THREAD
+#if defined(LISP_FEATURE_SB_THREAD) && !defined(LISP_FEATURE_SB_SAFEPOINT)
     os_sem_t state_sem;
     os_sem_t state_not_running_sem;
     os_sem_t state_not_stopped_sem;
-# ifdef LISP_FEATURE_SB_SAFEPOINT
-   /* For safepoint-based builds, together with thread's
-    * csp_around_foreign_call pointer target, thread_qrl(thread) makes
-    * `quickly revokable lock'. Unlike most mutexes, this one is
-    * normally locked; by convention, other thread may read and use the
-    * thread's FFI-CSP location _either_ when the former holds the
-    * lock(mutex) _or_ when page permissions for FFI-CSP location were
-    * set to read-only.
-    *
-    * Combined semantic of QRL is not the same as the semantic of mutex
-    * returned by this function; rather, the mutex, when released by the
-    * owning thread, provides an edge-triggered notification of QRL
-    * release, which is represented by writing non-null
-    * csp_around_foreign_call.
-    *
-    * When owner thread is `in Lisp' (i.e. a heap mutator), its FFI-CSP
-    * contains null, otherwise it points to the top of C stack that
-    * should be preserved by GENCGC. If another thread needs to wait for
-    * mutator state change with `in Lisp => in C' direction, it disables
-    * FFI-CSP overwrite using page protection, and takes the mutex
-    * returned by thread_qrl(). Page fault handler normally ends up in a
-    * routine releasing this mutex and waiting for some appropriate
-    * event to take it back.
-    *
-    * This way, each thread may modify its own FFI-CSP content freely
-    * without memory barriers (paying with exception handling overhead
-    * whenever a contention happens). */
-    pthread_mutex_t qrl_lock;
-# endif
 #else
-    /* An unused field follows, to ensure that the struct in non-empty
+    /* An unused field follows, to ensure that the struct is non-empty
      * for non-GCC compilers. */
     int unused;
 #endif
@@ -258,32 +231,39 @@ StaticSymbolFunction(lispobj sym)
 #define access_control_frame_pointer(thread) \
     ((thread)->control_frame_pointer)
 #  endif
-#elif defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
+#else
+#  if defined(BINDING_STACK_POINTER)
 #define get_binding_stack_pointer(thread)       \
     SymbolValue(BINDING_STACK_POINTER, thread)
 #define set_binding_stack_pointer(thread,value) \
     SetSymbolValue(BINDING_STACK_POINTER, (lispobj)(value), thread)
-#define access_control_stack_pointer(thread)    \
-    (current_control_stack_pointer)
-#else
+#  else
 #define get_binding_stack_pointer(thread)       \
     (current_binding_stack_pointer)
 #define set_binding_stack_pointer(thread,value) \
     (current_binding_stack_pointer = (lispobj *)(value))
-#define access_control_stack_pointer(thread) \
+#  endif
+#define access_control_stack_pointer(thread)    \
     (current_control_stack_pointer)
+#  if !defined(LISP_FEATURE_X86) && !defined(LISP_FEATURE_X86_64)
 #define access_control_frame_pointer(thread) \
     (current_control_frame_pointer)
+#  endif
 #endif
 
 #if defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_GCC_TLS)
 extern __thread struct thread *current_thread;
 #endif
 
-#ifdef LISP_FEATURE_SB_SAFEPOINT
-# define THREAD_CSP_PAGE_SIZE BACKEND_PAGE_BYTES
-#else
+#ifndef LISP_FEATURE_SB_SAFEPOINT
 # define THREAD_CSP_PAGE_SIZE 0
+#elif defined(LISP_FEATURE_PPC)
+  /* BACKEND_PAGE_BYTES is nice and large on this platform, but therefore
+   * does not fit into an immediate, making it awkward to access the page
+   * relative to the thread-tn... */
+# define THREAD_CSP_PAGE_SIZE 4096
+#else
+# define THREAD_CSP_PAGE_SIZE BACKEND_PAGE_BYTES
 #endif
 
 #ifdef LISP_FEATURE_WIN32
@@ -383,8 +363,6 @@ int wake_thread_posix(os_thread_t os_thread);
 #  endif
 # endif
 
-#define thread_qrl(th) (&(th)->nonpointer_data->qrl_lock)
-
 static inline
 void push_gcing_safety(struct gcing_safety *into)
 {
@@ -394,11 +372,15 @@ void push_gcing_safety(struct gcing_safety *into)
          *th->csp_around_foreign_call)) {
         *th->csp_around_foreign_call = 0;
         asm volatile ("");
+#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
         into->pc_around_foreign_call = th->pc_around_foreign_call;
         th->pc_around_foreign_call = 0;
         asm volatile ("");
+#endif
     } else {
+#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
         into->pc_around_foreign_call = 0;
+#endif
     }
 }
 
@@ -410,8 +392,10 @@ void pop_gcing_safety(struct gcing_safety *from)
         asm volatile ("");
         *th->csp_around_foreign_call = from->csp_around_foreign_call;
         asm volatile ("");
+#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
         th->pc_around_foreign_call = from->pc_around_foreign_call;
         asm volatile ("");
+#endif
     }
 }