Merge branch 'master-glibc-2.21' into master-glibc-2.23

6 files changed, 228 insertions, 112 deletions

diff --git a/include/pthread/pthread.h b/include/pthread/pthread.h
index f0d080a..3aa6a93 100644
--- a/include/pthread/pthread.h
+++ b/include/pthread/pthread.h
@@ -79,60 +79,71 @@ __BEGIN_DECLS
 
 /* Initialize the thread attribute object in *ATTR to the default
    values.  */
-extern int pthread_attr_init (pthread_attr_t *__attr);
+extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1));
 
 /* Destroy the thread attribute object in *ATTR.  */
-extern int pthread_attr_destroy (pthread_attr_t *__attr);
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the inheritsched attribute in *ATTR in
    *INHERITSCHED.  */
 extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr,
-					 int *__restrict __inheritsched);
+					 int *__restrict __inheritsched)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the inheritsched attribute in *ATTR to
    INHERITSCHED.  */
 extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
-					 int __inheritsched);
+					 int __inheritsched)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the schedparam attribute in *ATTR in *PARAM.  */
 extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
-				       struct sched_param *__restrict __param);
+				       struct sched_param *__restrict __param)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the schedparam attribute in *ATTR to PARAM.  */
 extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
-				       const struct sched_param *__restrict __param);
+				       const struct sched_param *__restrict
+				       __param) __THROW __nonnull ((1, 2));
 
 
 /* Return the value of the schedpolicy attribute in *ATTR to *POLICY.  */
 extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr,
-					int *__restrict __policy);
+					int *__restrict __policy)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the schedpolicy attribute in *ATTR to POLICY.  */
 extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr,
-					int __policy);
+					int __policy)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the contentionscope attribute in *ATTR in
    *CONTENTIONSCOPE.  */
 extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
-				  int *__restrict __contentionscope);
+				  int *__restrict __contentionscope)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the contentionscope attribute in *ATTR to
    CONTENTIONSCOPE.  */
 extern int pthread_attr_setscope (pthread_attr_t *__attr,
-				  int __contentionscope);
+				  int __contentionscope)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the stackaddr attribute in *ATTR in
    *STACKADDR.  */
 extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr,
-				      void **__restrict __stackaddr);
+				      void **__restrict __stackaddr)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the stackaddr attribute in *ATTR to STACKADDR.  */
 extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
-				      void *__stackaddr);
+				      void *__stackaddr)
+	__THROW __nonnull ((1));
 
 
 #ifdef __USE_XOPEN2K
@@ -140,51 +151,60 @@ extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
    in *STACKADDR and *STACKSIZE respectively.  */
 extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
 				  void **__restrict __stackaddr,
-				  size_t *__restrict __stacksize);
+				  size_t *__restrict __stacksize)
+	__THROW __nonnull ((1, 2, 3));
 
 /* Set the value of the stackaddr and stacksize attributes in *ATTR to
    STACKADDR and STACKSIZE respectively.  */
 extern int pthread_attr_setstack (pthread_attr_t *__attr,
 				  void *__stackaddr,
-				  size_t __stacksize);
+				  size_t __stacksize)
+	__THROW __nonnull ((1));
 #endif
 
 
 /* Return the value of the detachstate attribute in *ATTR in
    *DETACHSTATE.  */
 extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
-					int *__detachstate);
+					int *__detachstate)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the detachstate attribute in *ATTR to
    DETACHSTATE.  */
 extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
-					int __detachstate);
+					int __detachstate)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the guardsize attribute in *ATTR in
    *GUARDSIZE.  */
 extern int pthread_attr_getguardsize (const pthread_attr_t *__restrict __attr,
-				      size_t *__restrict __guardsize);
+				      size_t *__restrict __guardsize)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the guardsize attribute in *ATTR to GUARDSIZE.  */
 extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
-				      size_t __guardsize);
+				      size_t __guardsize)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the stacksize attribute in *ATTR in
    *STACKSIZE.  */
 extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr,
-				      size_t *__restrict __stacksize);
+				      size_t *__restrict __stacksize)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the stacksize attribute in *ATTR to STACKSIZE.  */
 extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
-				      size_t __stacksize);
+				      size_t __stacksize)
+	__THROW __nonnull ((1));
 
 #ifdef __USE_GNU
 /* Initialize thread attribute *ATTR with attributes corresponding to the
    already running thread THREAD.  It shall be called on an uninitialized ATTR
    and destroyed with pthread_attr_destroy when no longer needed.  */
-extern int pthread_getattr_np (pthread_t __thr, pthread_attr_t *__attr);
+extern int pthread_getattr_np (pthread_t __thr, pthread_attr_t *__attr)
+	__THROW __nonnull ((2));
 #endif
 
 
@@ -193,7 +213,7 @@ extern int pthread_getattr_np (pthread_t __thr, pthread_attr_t *__attr);
 extern int pthread_create (pthread_t *__restrict __threadp,
 			   __const pthread_attr_t *__restrict __attr,
 			   void *(*__start_routine)(void *),
-			   void *__restrict __arg);
+			   void *__restrict __arg) __THROWNL __nonnull ((1, 3));
 
 /* Terminate the current thread and make STATUS available to any
    thread that might join us.  */
@@ -223,7 +243,7 @@ pthread_equal (pthread_t __t1, pthread_t __t2)
 
 
 /* Return the thread ID of the calling thread.  */
-extern pthread_t pthread_self (void);
+extern pthread_t pthread_self (void) __THROW;
 
 
 /* Mutex attributes.  */
@@ -255,54 +275,64 @@ extern pthread_t pthread_self (void);
 
 /* Initialize the mutex attribute object in *ATTR to the default
    values.  */
-extern int pthread_mutexattr_init(pthread_mutexattr_t *__attr);
+extern int pthread_mutexattr_init(pthread_mutexattr_t *__attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the mutex attribute structure in *ATTR.  */
-extern int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr);
+extern int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr)
+	__THROW __nonnull ((1));
 
 
 #ifdef __USE_UNIX98
 /* Return the value of the prioceiling attribute in *ATTR in
    *PRIOCEILING.  */
 extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict __attr,
-					    int *__restrict __prioceiling);
+					    int *__restrict __prioceiling)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the prioceiling attribute in *ATTR to
    PRIOCEILING.  */
 extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *__attr,
-					    int __prioceiling);
+					    int __prioceiling)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the protocol attribute in *ATTR in
    *PROTOCOL.  */
 extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict __attr,
-					 int *__restrict __protocol);
+					 int *__restrict __protocol)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the protocol attribute in *ATTR to PROTOCOL.  */
 extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *__attr,
-					 int __protocol);
+					 int __protocol)
+	__THROW __nonnull ((1));
 #endif
 
 
 /* Return the value of the process shared attribute in *ATTR in
    *PSHARED.  */
 extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict __attr,
-					int *__restrict __pshared);
+					int *__restrict __pshared)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the process shared attribute in *ATTR to
    PSHARED.  */
 extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *__attr,
-					int __pshared);
+					int __pshared)
+	__THROW __nonnull ((1));
 
 
 #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
 /* Return the value of the type attribute in *ATTR in *TYPE.  */
 extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict __attr,
-				     int *__restrict __type);
+				     int *__restrict __type)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the type attribute in *ATTR to TYPE.  */
 extern int pthread_mutexattr_settype(pthread_mutexattr_t *__attr,
-				     int __type);
+				     int __type)
+	__THROW __nonnull ((1));
 #endif
 
 
@@ -323,42 +353,50 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *__attr,
 /* Create a mutex with attributes given by ATTR and store it in
    *__MUTEX.  */
 extern int pthread_mutex_init (struct __pthread_mutex *__restrict __mutex,
-			       const pthread_mutexattr_t *__restrict __attr);
+			       const pthread_mutexattr_t *__restrict __attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the mutex __MUTEX.  */
-extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex);
+extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex)
+	__THROW __nonnull ((1));
 
 /* Wait until lock for MUTEX becomes available and lock it.  */
 extern int pthread_mutex_lock (pthread_mutex_t *__mutex);
 
 /* Try to lock MUTEX.  */
-extern int pthread_mutex_trylock (pthread_mutex_t *__mutex);
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+	__THROWNL __nonnull ((1));
 
 #ifdef __USE_XOPEN2K
 /* Try to lock MUTEX, block until *ABSTIME if it is already held.  */
 extern int pthread_mutex_timedlock (struct __pthread_mutex *__restrict __mutex,
-				    const struct timespec *__restrict __abstime);
+				    const struct timespec *__restrict __abstime)
+	__THROWNL __nonnull ((1, 2));
 #endif
 
 /* Unlock MUTEX.  */
-extern int pthread_mutex_unlock (pthread_mutex_t *__mutex);
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+	__THROWNL __nonnull ((1));
 
 /* Transfer ownership of the mutex MUTEX to the thread TID.  The
    caller must own the lock.  */
 extern int __pthread_mutex_transfer_np (struct __pthread_mutex *__mutex,
-					pthread_t __tid);
+					pthread_t __tid)
+	__THROWNL __nonnull ((1));
 
 
 #ifdef __USE_UNIX98
 /* Return the priority ceiling of mutex *MUTEX in *PRIOCEILING.  */
 extern int pthread_mutex_getprioceiling (const pthread_mutex_t *__restrict __mutex,
-					 int *__restrict __prioceiling);
+					 int *__restrict __prioceiling)
+	__THROW __nonnull ((1, 2));
 
 /* After acquiring the mutex *MUTEX, set its priority ceiling to PRIO
    and return the old priority ceiling in *OLDPRIO.  Before returning,
    release the mutex.  */
 extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
-					 int __prio, int *__restrict __oldprio);
+					 int __prio, int *__restrict __oldprio)
+	__THROW __nonnull ((1, 3));
 #endif
 
 
@@ -369,32 +407,38 @@ extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
 
 /* Initialize the condition attribute in *ATTR to the default
    values.  */
-extern int pthread_condattr_init (pthread_condattr_t *__attr);
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the condition attribute structure in *ATTR.  */
-extern int pthread_condattr_destroy (pthread_condattr_t *__attr);
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+	__THROW __nonnull ((1));
 
 
 #ifdef __USE_XOPEN2K
 /* Return the value of the clock attribute in *ATTR in *CLOCK_ID.  */
 extern int pthread_condattr_getclock (const pthread_condattr_t *__restrict __attr,
-				      __clockid_t *__restrict __clock_id);
+				      __clockid_t *__restrict __clock_id)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the clock attribute in *ATTR to CLOCK_ID.  */
 extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
-				      __clockid_t __clock_id);
+				      __clockid_t __clock_id)
+	__THROW __nonnull ((1));
 #endif
 
 
 /* Return the value of the process shared attribute in *ATTR in
    *PSHARED.  */
 extern int pthread_condattr_getpshared (const pthread_condattr_t *__restrict __attr,
-					int *__restrict __pshared);
+					int *__restrict __pshared)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the process shared attribute in *ATTR to
    PSHARED.  */
 extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
-					int __pshared);
+					int __pshared)
+	__THROW __nonnull ((1));
 
 
 /* Condition variables.  */
@@ -404,22 +448,27 @@ extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
 #define PTHREAD_COND_INITIALIZER __PTHREAD_COND_INITIALIZER
 
 extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
-			      const pthread_condattr_t *__restrict __attr);
+			      const pthread_condattr_t *__restrict __attr)
+	__THROW __nonnull ((1));
 
-extern int pthread_cond_destroy (pthread_cond_t *__cond);
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+	__THROW __nonnull ((1));
 
 /* Unblock at least one of the threads that are blocked on condition
    variable COND.  */
-extern int pthread_cond_signal (pthread_cond_t *__cond);
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+	__THROWNL __nonnull ((1));
 
 /* Unblock all threads that are blocked on condition variable COND.  */
-extern int pthread_cond_broadcast (pthread_cond_t *__cond);
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+	__THROWNL __nonnull ((1));
 
 /* Block on condition variable COND.  MUTEX should be held by the
    calling thread.  On success, MUTEX will be held by the calling
    thread.  */
 extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
-			      pthread_mutex_t *__restrict __mutex);
+			      pthread_mutex_t *__restrict __mutex)
+	 __nonnull ((1, 2));
 
 /* Block on condition variable COND.  MUTEX should be held by the
    calling thread. On success, MUTEX will be held by the calling
@@ -427,7 +476,8 @@ extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
    returned, and MUTEX will nevertheless be held.  */
 extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
 				   pthread_mutex_t *__restrict __mutex,
-				   __const struct timespec *__restrict __abstime);
+				   __const struct timespec *__restrict __abstime)
+	 __nonnull ((1, 2, 3));
 
 
 /* Spin locks.  */
@@ -439,22 +489,27 @@ extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
 #define PTHREAD_SPINLOCK_INITIALIZER __PTHREAD_SPIN_LOCK_INITIALIZER
 
 /* Destroy the spin lock object LOCK.  */
-extern int pthread_spin_destroy (pthread_spinlock_t *__lock);
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+	__nonnull ((1));
 
 /* Initialize the spin lock object LOCK.  PSHARED determines whether
    the spin lock can be operated upon by multiple processes.  */
-extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared);
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+	__nonnull ((1));
 
 /* Lock the spin lock object LOCK.  If the lock is held by another
    thread spin until it becomes available.  */
-extern int pthread_spin_lock (pthread_spinlock_t *__lock);
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+	__nonnull ((1));
 
 /* Lock the spin lock object LOCK.  Fail if the lock is held by
    another thread.  */
-extern int pthread_spin_trylock (pthread_spinlock_t *__lock);
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+	__nonnull ((1));
 
 /* Unlock the spin lock object LOCK.  */
-extern int pthread_spin_unlock (pthread_spinlock_t *__lock);
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+	__nonnull ((1));
 
 # ifdef __USE_EXTERN_INLINES
 
@@ -503,21 +558,25 @@ pthread_spin_unlock (pthread_spinlock_t *__lock)
 
 /* Initialize rwlock attribute object in *ATTR to the default
    values.  */
-extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr);
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the rwlock attribute object in *ATTR.  */
-extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr);
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the process shared attribute in *ATTR in
    *PSHARED.  */
 extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *__restrict __attr,
-					  int *__restrict __pshared);
+					  int *__restrict __pshared)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the process shared atrribute in *ATTR to
    PSHARED.  */
 extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
-					  int __pshared);
+					  int __pshared)
+	__THROW __nonnull ((1));
 
 
 /* rwlocks.  */
@@ -528,39 +587,48 @@ extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
 /* Create a rwlock object with attributes given by ATTR and strore the
    result in *RWLOCK.  */
 extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
-				const pthread_rwlockattr_t *__restrict __attr);
+				const pthread_rwlockattr_t *__restrict __attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the rwlock *RWLOCK.  */
-extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+	__THROW __nonnull ((1));
 
 /* Acquire the rwlock *RWLOCK for reading.  */
-extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+	__THROWNL __nonnull ((1));
 
 /* Acquire the rwlock *RWLOCK for reading.  */
-extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+	__THROWNL __nonnull ((1));
 
 # ifdef __USE_XOPEN2K
 /* Acquire the rwlock *RWLOCK for reading blocking until *ABSTIME if
    it is already held.  */
 extern int pthread_rwlock_timedrdlock (struct __pthread_rwlock *__restrict __rwlock,
-				       const struct timespec *__restrict __abstime);
+				       const struct timespec *__restrict __abstime)
+	__THROWNL __nonnull ((1, 2));
 # endif
 
 /* Acquire the rwlock *RWLOCK for writing.  */
-extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+	__THROWNL __nonnull ((1));
 
 /* Try to acquire the rwlock *RWLOCK for writing.  */
-extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+	__THROWNL __nonnull ((1));
 
 # ifdef __USE_XOPEN2K
 /* Acquire the rwlock *RWLOCK for writing blocking until *ABSTIME if
    it is already held.  */
 extern int pthread_rwlock_timedwrlock (struct __pthread_rwlock *__restrict __rwlock,
-				       const struct timespec *__restrict __abstime);
+				       const struct timespec *__restrict __abstime)
+	__THROWNL __nonnull ((1, 2));
 # endif
 
 /* Release the lock held by the current thread on *RWLOCK.  */
-extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+	__THROWNL __nonnull ((1));
 
 #endif /* __USE_UNIX98 || __USE_XOPEN2K */
 
@@ -612,21 +680,25 @@ extern void pthread_testcancel (void);
 
 /* Initialize barrier attribute object in *ATTR to the default
    values.  */
-extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr);
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+	__THROW __nonnull ((1));
 
 /* Destroy the barrier attribute object in *ATTR.  */
-extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr);
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+	__THROW __nonnull ((1));
 
 
 /* Return the value of the process shared attribute in *ATTR in
    *PSHARED.  */
 extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *__restrict __attr,
-					   int *__restrict __pshared);
+					   int *__restrict __pshared)
+	__THROW __nonnull ((1, 2));
 
 /* Set the value of the process shared atrribute in *ATTR to
    PSHARED.  */
 extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
-					   int __pshared);
+					   int __pshared)
+	__THROW __nonnull ((1));
 
 
 /* Barriers.  */
@@ -640,13 +712,16 @@ extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
 /* Initialize barrier BARRIER.  */
 extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
 				const pthread_barrierattr_t *__restrict __attr,
-				unsigned __count);
+				unsigned __count)
+	__THROW __nonnull ((1));
 
 /* Destroy barrier BARRIER.  */
-extern int pthread_barrier_destroy (pthread_barrier_t *__barrier);
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+	__THROW __nonnull ((1));
 
 /* Wait on barrier BARRIER.  */
-extern int pthread_barrier_wait (pthread_barrier_t *__barrier);
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+	__THROWNL __nonnull ((1));
 
 #endif /* __USE_XOPEN2K */
 
@@ -660,17 +735,19 @@ extern int pthread_barrier_wait (pthread_barrier_t *__barrier);
    On thread destruction, DESTRUCTOR shall be called with the thread
    specific data associate with KEY if it is not NULL.  */
 extern int pthread_key_create (pthread_key_t *__key,
-			       void (*__destructor) (void *));
+			       void (*__destructor) (void *))
+	__THROW __nonnull ((1));
 
 /* Delete the thread specific data key KEY.  The associated destructor
    function is not called.  */
-extern int pthread_key_delete (pthread_key_t __key);
+extern int pthread_key_delete (pthread_key_t __key) __THROW;
 
 /* Return the caller thread's thread specific value of KEY.  */
-extern void *pthread_getspecific (pthread_key_t __key);
+extern void *pthread_getspecific (pthread_key_t __key) __THROW;
 
 /* Set the caller thread's thread specific value of KEY to VALUE.  */
-extern int pthread_setspecific (pthread_key_t __key, const void *__value);
+extern int pthread_setspecific (pthread_key_t __key, const void *__value)
+	__THROW;
 
 
 /* Dynamic package initialization.  */
@@ -682,17 +759,17 @@ extern int pthread_setspecific (pthread_key_t __key, const void *__value);
 /* Call INIT_ROUTINE if this function has never been called with
    *ONCE_CONTROL, otherwise do nothing.  */
 extern int pthread_once (pthread_once_t *__once_control,
-			 void (*__init_routine) (void));
+			 void (*__init_routine) (void)) __nonnull ((1, 2));
 
 
 /* Concurrency.  */
 
 #ifdef __USE_UNIX98
 /* Set the desired concurrency level to NEW_LEVEL.  */
-extern int pthread_setconcurrency (int __new_level);
+extern int pthread_setconcurrency (int __new_level) __THROW;
 
 /* Get the current concurrency level.  */
-extern int pthread_getconcurrency (void);
+extern int pthread_getconcurrency (void) __THROW;
 #endif
 
 
@@ -706,20 +783,21 @@ extern int pthread_getconcurrency (void);
    which they were registered and the parent and child handlers in the
    order in which they were registered.  */
 extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void),
-			   void (*__child) (void));
+			   void (*__child) (void)) __THROW;
 
 
 /* Signals (should be in <signal.h>).  */
 
 /* Send signal SIGNO to thread THREAD.  */
-extern int pthread_kill (pthread_t __thr, int __signo);
+extern int pthread_kill (pthread_t __thr, int __signo) __THROW;
 
 
 /* Time.  */
 
 #ifdef __USE_XOPEN2K
 /* Return the thread cpu clock.  */
-extern int pthread_getcpuclockid (pthread_t __thr, __clockid_t *__clock);
+extern int pthread_getcpuclockid (pthread_t __thr, __clockid_t *__clock)
+	__THROW __nonnull ((2));
 #endif
 
 
@@ -727,21 +805,23 @@ extern int pthread_getcpuclockid (pthread_t __thr, __clockid_t *__clock);
 
 /* Return thread THREAD's scheduling paramters.  */
 extern int pthread_getschedparam (pthread_t __thr, int *__restrict __policy,
-				  struct sched_param *__restrict __param);
+				  struct sched_param *__restrict __param)
+	__THROW __nonnull ((2, 3));
 
 /* Set thread THREAD's scheduling paramters.  */
 extern int pthread_setschedparam (pthread_t __thr, int __policy,
-				  const struct sched_param *__param);
+				  const struct sched_param *__param)
+	__THROW __nonnull ((3));
 
 /* Set thread THREAD's scheduling priority.  */
-extern int pthread_setschedprio (pthread_t __thr, int __prio);
+extern int pthread_setschedprio (pthread_t __thr, int __prio) __THROW;
 
 #ifdef __USE_GNU
 /* Yield the processor to another thread or process.
    This function is similar to the POSIX `sched_yield' function but
    might be differently implemented in the case of a m-on-n thread
    implementation.  */
-extern int pthread_yield (void);
+extern int pthread_yield (void) __THROW;
 #endif
 
 
diff --git a/sysdeps/generic/pt-key-create.c b/sysdeps/generic/pt-key-create.c
index de05095..33f691b 100644
--- a/sysdeps/generic/pt-key-create.c
+++ b/sysdeps/generic/pt-key-create.c
@@ -21,9 +21,10 @@
 #include <pt-internal.h>
 
 int
-pthread_key_create (pthread_key_t *key, void (*destructor) (void *))
+__pthread_key_create (pthread_key_t *key, void (*destructor) (void *))
 {
   return ENOSYS;
 }
 
+strong_alias (__pthread_key_create, pthread_key_create)
 stub_warning (pthread_key_create)
diff --git a/sysdeps/generic/raise.c b/sysdeps/generic/raise.c
index 3c497da..f086665 100644
--- a/sysdeps/generic/raise.c
+++ b/sysdeps/generic/raise.c
@@ -46,3 +46,5 @@ raise (int signo)
     return __kill (__getpid (), signo);
 }
 
+libc_hidden_def (raise)
+weak_alias (raise, gsignal)
diff --git a/sysdeps/generic/shm-directory.h b/sysdeps/generic/shm-directory.h
new file mode 100644
index 0000000..8950284
--- /dev/null
+++ b/sysdeps/generic/shm-directory.h
@@ -0,0 +1,31 @@
+/* Header for directory for shm/sem files.  libpthread version.
+   Copyright (C) 2014-2015 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
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef _SHM_DIRECTORY_H
+
+#include <sysdeps/posix/shm-directory.h>
+
+/* For libpthread the __shm_directory function lives in libpthread.
+   We don't want PLT calls from there.  But it's also used from
+   librt, so it cannot just be declared hidden.  */
+
+#if IS_IN (libpthread)
+hidden_proto (__shm_directory)
+#endif
+
+#endif  /* shm-directory.h */
diff --git a/sysdeps/hurd/pt-key-create.c b/sysdeps/hurd/pt-key-create.c
index 42c7c85..f26ec36 100644
--- a/sysdeps/hurd/pt-key-create.c
+++ b/sysdeps/hurd/pt-key-create.c
@@ -108,4 +108,3 @@ __pthread_key_create (pthread_key_t *key, void (*destructor) (void *))
   return 0;
 }
 strong_alias (__pthread_key_create, pthread_key_create)
-hidden_def (__pthread_key_create)
diff --git a/sysdeps/mach/hurd/pt-sigstate.c b/sysdeps/mach/hurd/pt-sigstate.c
index 2af3e39..74fd72a 100644
--- a/sysdeps/mach/hurd/pt-sigstate.c
+++ b/sysdeps/mach/hurd/pt-sigstate.c
@@ -43,24 +43,27 @@ __pthread_sigstate (struct __pthread *thread, int how,
     *oset = ss->blocked;
 
   if (set)
-    switch (how)
-      {
-      case SIG_BLOCK:
-	ss->blocked |= *set;
-	break;
-
-      case SIG_SETMASK:
-	ss->blocked = *set;
-	break;
-
-      case SIG_UNBLOCK:
-	ss->blocked &= ~*set;
-	break;
-
-      default:
-	err = EINVAL;
-	break;
-      }
+    {
+      switch (how)
+	{
+	case SIG_BLOCK:
+	  ss->blocked |= *set;
+	  break;
+
+	case SIG_SETMASK:
+	  ss->blocked = *set;
+	  break;
+
+	case SIG_UNBLOCK:
+	  ss->blocked &= ~*set;
+	  break;
+
+	default:
+	  err = EINVAL;
+	  break;
+	}
+      ss->blocked &= ~_SIG_CANT_MASK;
+    }
 
   if (! err && clear_pending)
     __sigemptyset (&ss->pending);