mass sync with glibc nptl

Signed-off-by: Austin Foxley <austinf@cetoncorp.com>

1 files changed, 219 insertions, 92 deletions

diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/sh/lowlevellock.h b/libpthread/nptl/sysdeps/unix/sysv/linux/sh/lowlevellock.h
index 45339f5e0..d7fada991 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/sh/lowlevellock.h
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/sh/lowlevellock.h
@@ -1,4 +1,5 @@
-/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+/* Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009
+   Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -19,28 +20,107 @@
 #ifndef _LOWLEVELLOCK_H
 #define _LOWLEVELLOCK_H	1
 
-#include <syscall.h>
+#ifndef __ASSEMBLER__
 #include <time.h>
 #include <sys/param.h>
 #include <bits/pthreadtypes.h>
+#include <bits/kernel-features.h>
+#endif
 
+#define SYS_futex		240
 #define FUTEX_WAIT		0
 #define FUTEX_WAKE		1
+#define FUTEX_CMP_REQUEUE	4
+#define FUTEX_WAKE_OP		5
+#define FUTEX_LOCK_PI		6
+#define FUTEX_UNLOCK_PI		7
+#define FUTEX_TRYLOCK_PI	8
+#define FUTEX_WAIT_BITSET	9
+#define FUTEX_WAKE_BITSET	10
+#define FUTEX_PRIVATE_FLAG	128
+#define FUTEX_CLOCK_REALTIME	256
+
+#define FUTEX_BITSET_MATCH_ANY	0xffffffff
+
+#define FUTEX_OP_CLEAR_WAKE_IF_GT_ONE	((4 << 24) | 1)
+
+/* Values for 'private' parameter of locking macros.  Yes, the
+   definition seems to be backwards.  But it is not.  The bit will be
+   reversed before passing to the system call.  */
+#define LLL_PRIVATE    0
+#define LLL_SHARED     FUTEX_PRIVATE_FLAG
+
+
+#if !defined NOT_IN_libc || defined IS_IN_rtld
+/* In libc.so or ld.so all futexes are private.  */
+# ifdef __ASSUME_PRIVATE_FUTEX
+#  define __lll_private_flag(fl, private) \
+  ((fl) | FUTEX_PRIVATE_FLAG)
+# else
+#  define __lll_private_flag(fl, private) \
+  ((fl) | THREAD_GETMEM (THREAD_SELF, header.private_futex))
+# endif
+#else
+# ifdef __ASSUME_PRIVATE_FUTEX
+#  define __lll_private_flag(fl, private) \
+  (((fl) | FUTEX_PRIVATE_FLAG) ^ (private))
+# else
+#  define __lll_private_flag(fl, private) \
+  (__builtin_constant_p (private)					      \
+   ? ((private) == 0							      \
+      ? ((fl) | THREAD_GETMEM (THREAD_SELF, header.private_futex))	      \
+      : (fl))								      \
+   : ((fl) | (((private) ^ FUTEX_PRIVATE_FLAG)				      \
+	      & THREAD_GETMEM (THREAD_SELF, header.private_futex))))
+# endif
+#endif
 
+#ifndef __ASSEMBLER__
 
 /* Initializer for compatibility lock.  */
-#define LLL_MUTEX_LOCK_INITIALIZER		(0)
-#define LLL_MUTEX_LOCK_INITIALIZER_LOCKED	(1)
-#define LLL_MUTEX_LOCK_INITIALIZER_WAITERS	(2)
-
-extern int __lll_mutex_lock_wait (int val, int *__futex) attribute_hidden;
-extern int __lll_mutex_timedlock_wait (int val, int *__futex,
-				       const struct timespec *abstime)
-     attribute_hidden;
-extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
-
+#define LLL_LOCK_INITIALIZER		(0)
+#define LLL_LOCK_INITIALIZER_LOCKED	(1)
+#define LLL_LOCK_INITIALIZER_WAITERS	(2)
+
+extern int __lll_lock_wait_private (int val, int *__futex)
+  attribute_hidden;
+extern int __lll_lock_wait (int val, int *__futex, int private)
+  attribute_hidden;
+extern int __lll_timedlock_wait (int val, int *__futex,
+				 const struct timespec *abstime, int private)
+  attribute_hidden;
+extern int __lll_robust_lock_wait (int val, int *__futex, int private)
+  attribute_hidden;
+extern int __lll_robust_timedlock_wait (int val, int *__futex,
+					const struct timespec *abstime,
+					int private)
+  attribute_hidden;
+extern int __lll_unlock_wake_private (int *__futex) attribute_hidden;
+extern int __lll_unlock_wake (int *__futex, int private) attribute_hidden;
+
+#define lll_trylock(futex) \
+  ({ unsigned char __result; \
+     __asm __volatile ("\
+	.align 2\n\
+	mova 1f,r0\n\
+	nop\n\
+	mov r15,r1\n\
+	mov #-8,r15\n\
+     0: mov.l @%1,r2\n\
+	cmp/eq r2,%3\n\
+	bf 1f\n\
+	mov.l %2,@%1\n\
+     1: mov r1,r15\n\
+	mov #-1,%0\n\
+	negc %0,%0"\
+	: "=r" (__result) \
+	: "r" (&(futex)), \
+	  "r" (LLL_LOCK_INITIALIZER_LOCKED), \
+	  "r" (LLL_LOCK_INITIALIZER) \
+	: "r0", "r1", "r2", "t", "memory"); \
+     __result; })
 
-#define lll_mutex_trylock(futex) \
+#define lll_robust_trylock(futex, id)	\
   ({ unsigned char __result; \
      __asm __volatile ("\
 	.align 2\n\
@@ -57,12 +137,12 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 	negc %0,%0"\
 	: "=r" (__result) \
 	: "r" (&(futex)), \
-	  "r" (LLL_MUTEX_LOCK_INITIALIZER_LOCKED), \
-	  "r" (LLL_MUTEX_LOCK_INITIALIZER) \
+	  "r" (id), \
+	  "r" (LLL_LOCK_INITIALIZER) \
 	: "r0", "r1", "r2", "t", "memory"); \
      __result; })
 
-#define lll_mutex_cond_trylock(futex) \
+#define lll_cond_trylock(futex) \
   ({ unsigned char __result; \
      __asm __volatile ("\
 	.align 2\n\
@@ -79,12 +159,12 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 	negc %0,%0"\
 	: "=r" (__result) \
 	: "r" (&(futex)), \
-	  "r" (LLL_MUTEX_LOCK_INITIALIZER_WAITERS), \
-	  "r" (LLL_MUTEX_LOCK_INITIALIZER) \
+	  "r" (LLL_LOCK_INITIALIZER_WAITERS), \
+	  "r" (LLL_LOCK_INITIALIZER) \
 	: "r0", "r1", "r2", "t", "memory"); \
      __result; })
 
-#define lll_mutex_lock(futex) \
+#define lll_lock(futex, private) \
   (void) ({ int __result, *__futex = &(futex); \
 	    __asm __volatile ("\
 		.align 2\n\
@@ -100,11 +180,37 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 		: "=&r" (__result) : "r" (1), "r" (__futex) \
 		: "r0", "r1", "t", "memory"); \
 	    if (__result) \
-	      __lll_mutex_lock_wait (__result, __futex); })
+	      { \
+		if (__builtin_constant_p (private) \
+		    && (private) == LLL_PRIVATE) \
+		  __lll_lock_wait_private (__result, __futex); \
+	        else \
+		  __lll_lock_wait (__result, __futex, (private));	\
+	      } \
+    })
+
+#define lll_robust_lock(futex, id, private) \
+  ({ int __result, *__futex = &(futex); \
+     __asm __volatile ("\
+	.align 2\n\
+	mova 1f,r0\n\
+	nop\n\
+	mov r15,r1\n\
+	mov #-8,r15\n\
+      0: mov.l @%2,%0\n\
+	tst %0,%0\n\
+	bf 1f\n\
+	mov.l %1,@%2\n\
+      1: mov r1,r15"\
+	: "=&r" (__result) : "r" (id), "r" (__futex) \
+	: "r0", "r1", "t", "memory"); \
+     if (__result) \
+       __result = __lll_robust_lock_wait (__result, __futex, private); \
+     __result; })
 
 /* Special version of lll_mutex_lock which causes the unlock function to
    always wakeup waiters.  */
-#define lll_mutex_cond_lock(futex) \
+#define lll_cond_lock(futex, private) \
   (void) ({ int __result, *__futex = &(futex); \
 	    __asm __volatile ("\
 		.align 2\n\
@@ -120,9 +226,28 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 		: "=&r" (__result) : "r" (2), "r" (__futex) \
 		: "r0", "r1", "t", "memory"); \
 	    if (__result) \
-	      __lll_mutex_lock_wait (__result, __futex); })
+	      __lll_lock_wait (__result, __futex, private); })
 
-#define lll_mutex_timedlock(futex, timeout) \
+#define lll_robust_cond_lock(futex, id, private) \
+  ({ int __result, *__futex = &(futex); \
+     __asm __volatile ("\
+	.align 2\n\
+	mova 1f,r0\n\
+	nop\n\
+	mov r15,r1\n\
+	mov #-8,r15\n\
+     0: mov.l @%2,%0\n\
+	tst %0,%0\n\
+	bf 1f\n\
+	mov.l %1,@%2\n\
+     1: mov r1,r15"\
+	: "=&r" (__result) : "r" (id | FUTEX_WAITERS), "r" (__futex) \
+	: "r0", "r1", "t", "memory"); \
+      if (__result) \
+	__result = __lll_robust_lock_wait (__result, __futex, private); \
+      __result; })
+
+#define lll_timedlock(futex, timeout, private) \
   ({ int __result, *__futex = &(futex); \
      __asm __volatile ("\
 	.align 2\n\
@@ -138,10 +263,30 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 	: "=&r" (__result) : "r" (1), "r" (__futex) \
 	: "r0", "r1", "t", "memory"); \
     if (__result) \
-      __result = __lll_mutex_timedlock_wait (__result, __futex, timeout); \
+      __result = __lll_timedlock_wait (__result, __futex, timeout, private); \
     __result; })
 
-#define lll_mutex_unlock(futex) \
+#define lll_robust_timedlock(futex, timeout, id, private) \
+  ({ int __result, *__futex = &(futex); \
+     __asm __volatile ("\
+	.align 2\n\
+	mova 1f,r0\n\
+	nop\n\
+	mov r15,r1\n\
+	mov #-8,r15\n\
+     0: mov.l @%2,%0\n\
+	tst %0,%0\n\
+	bf 1f\n\
+	mov.l %1,@%2\n\
+     1: mov r1,r15"\
+	: "=&r" (__result) : "r" (id), "r" (__futex) \
+	: "r0", "r1", "t", "memory"); \
+    if (__result) \
+      __result = __lll_robust_timedlock_wait (__result, __futex, \
+					      timeout, private); \
+    __result; })
+
+#define lll_unlock(futex, private) \
   (void) ({ int __result, *__futex = &(futex); \
 	    __asm __volatile ("\
 		.align 2\n\
@@ -155,22 +300,45 @@ extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
 		: "=&r" (__result) : "r" (__futex) \
 		: "r0", "r1", "memory"); \
 	    if (__result) \
-	      __lll_mutex_unlock_wake (__futex); })
-
-#define lll_mutex_islocked(futex) \
-  (futex != 0)
-
-
-/* We have a separate internal lock implementation which is not tied
-   to binary compatibility.  */
-
-/* Type for lock object.  */
-typedef int lll_lock_t;
-
-/* Initializers for lock.  */
-#define LLL_LOCK_INITIALIZER		(0)
-#define LLL_LOCK_INITIALIZER_LOCKED	(1)
+	      { \
+		if (__builtin_constant_p (private) \
+		    && (private) == LLL_PRIVATE) \
+		  __lll_unlock_wake_private (__futex); \
+	        else \
+		  __lll_unlock_wake (__futex, (private)); \
+	      } \
+    })
+
+#define lll_robust_unlock(futex, private) \
+  (void) ({ int __result, *__futex = &(futex); \
+	    __asm __volatile ("\
+		.align 2\n\
+		mova 1f,r0\n\
+		mov r15,r1\n\
+		mov #-6,r15\n\
+	     0: mov.l @%1,%0\n\
+		and %2,%0\n\
+		mov.l %0,@%1\n\
+	     1: mov r1,r15"\
+		: "=&r" (__result) : "r" (__futex), "r" (FUTEX_WAITERS) \
+		: "r0", "r1", "memory");	\
+	    if (__result) \
+	      __lll_unlock_wake (__futex, private); })
 
+#define lll_robust_dead(futex, private)		       \
+  (void) ({ int __ignore, *__futex = &(futex); \
+	    __asm __volatile ("\
+		.align 2\n\
+		mova 1f,r0\n\
+		mov r15,r1\n\
+		mov #-6,r15\n\
+	     0: mov.l @%1,%0\n\
+		or %2,%0\n\
+		mov.l %0,@%1\n\
+	     1: mov r1,r15"\
+		: "=&r" (__ignore) : "r" (__futex), "r" (FUTEX_OWNER_DIED) \
+		: "r0", "r1", "memory");	\
+	    lll_futex_wake (__futex, 1, private); })
 
 # ifdef NEED_SYSCALL_INST_PAD
 #  define SYSCALL_WITH_INST_PAD "\
@@ -180,27 +348,17 @@ typedef int lll_lock_t;
 	trapa #0x14"
 # endif
 
-#define lll_futex_wait(futex, val) \
-  do {									      \
-    int __ignore;							      \
-    register unsigned long __r3 __asm ("r3") = SYS_futex;			      \
-    register unsigned long __r4 __asm ("r4") = (unsigned long) (futex);	      \
-    register unsigned long __r5 __asm ("r5") = FUTEX_WAIT;		      \
-    register unsigned long __r6 __asm ("r6") = (unsigned long) (val);	      \
-    register unsigned long __r7 __asm ("r7") = 0;				      \
-    __asm __volatile (SYSCALL_WITH_INST_PAD				      \
-		      : "=z" (__ignore)					      \
-		      : "r" (__r3), "r" (__r4), "r" (__r5),		      \
-			"r" (__r6), "r" (__r7)				      \
-		      : "memory", "t");					      \
-  } while (0)
+#define lll_futex_wait(futex, val, private) \
+  lll_futex_timed_wait (futex, val, NULL, private)
+
 
-#define lll_futex_timed_wait(futex, val, timeout) \
+#define lll_futex_timed_wait(futex, val, timeout, private) \
   ({									      \
     int __status;							      \
     register unsigned long __r3 __asm ("r3") = SYS_futex;			      \
     register unsigned long __r4 __asm ("r4") = (unsigned long) (futex);	      \
-    register unsigned long __r5 __asm ("r5") = FUTEX_WAIT;		      \
+    register unsigned long __r5 __asm ("r5")				      \
+      = __lll_private_flag (FUTEX_WAIT, private);			      \
     register unsigned long __r6 __asm ("r6") = (unsigned long) (val);	      \
     register unsigned long __r7 __asm ("r7") = (timeout);			      \
     __asm __volatile (SYSCALL_WITH_INST_PAD				      \
@@ -212,12 +370,13 @@ typedef int lll_lock_t;
   })
 
 
-#define lll_futex_wake(futex, nr) \
+#define lll_futex_wake(futex, nr, private) \
   do {									      \
     int __ignore;							      \
     register unsigned long __r3 __asm ("r3") = SYS_futex;			      \
     register unsigned long __r4 __asm ("r4") = (unsigned long) (futex);	      \
-    register unsigned long __r5 __asm ("r5") = FUTEX_WAKE;		      \
+    register unsigned long __r5 __asm ("r5")				      \
+      = __lll_private_flag (FUTEX_WAKE, private);			      \
     register unsigned long __r6 __asm ("r6") = (unsigned long) (nr);	      \
     register unsigned long __r7 __asm ("r7") = 0;				      \
     __asm __volatile (SYSCALL_WITH_INST_PAD				      \
@@ -228,33 +387,19 @@ typedef int lll_lock_t;
   } while (0)
 
 
-extern int lll_unlock_wake_cb (int *__futex) attribute_hidden;
-
-
-/* The states of a lock are:
-    0  -  untaken
-    1  -  taken by one user
-    2  -  taken by more users */
-
-#define lll_trylock(futex) lll_mutex_trylock (futex)
-#define lll_lock(futex) lll_mutex_lock (futex)
-#define lll_unlock(futex) lll_mutex_unlock (futex)
-
 #define lll_islocked(futex) \
   (futex != LLL_LOCK_INITIALIZER)
 
-
 /* The kernel notifies a process with uses CLONE_CLEARTID via futex
    wakeup when the clone terminates.  The memory location contains the
    thread ID while the clone is running and is reset to zero
    afterwards.  */
 
-extern int __lll_wait_tid (int *tid) attribute_hidden;
 #define lll_wait_tid(tid) \
   do {									      \
     __typeof (tid) *__tid = &(tid);					      \
     while (*__tid != 0)							      \
-      lll_futex_wait (__tid, *__tid);					      \
+      lll_futex_wait (__tid, *__tid, LLL_SHARED);			      \
   } while (0)
 
 extern int __lll_timedwait_tid (int *tid, const struct timespec *abstime)
@@ -271,24 +416,6 @@ extern int __lll_timedwait_tid (int *tid, const struct timespec *abstime)
       }									      \
     __result; })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond) attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-				 const struct timespec *abstime)
-     attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond) attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond) attribute_hidden;
-
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
+#endif  /* !__ASSEMBLER__ */
 
 #endif  /* lowlevellock.h */