replace all remaining internal uses of pthread_self with __pthread_self

prior to version 1.1.0, the difference between pthread_self (the
public function) and __pthread_self (the internal macro or inline
function) was that the former would lazily initialize the thread
pointer if it was not already initialized, whereas the latter would
crash in this case. since lazy initialization is no longer supported,
use of pthread_self no longer makes sense; it simply generates larger,
slower code.

src/locale/uselocale.c

@@ -4,7 +4,7 @@
 
 locale_t uselocale(locale_t l)
 {
-	pthread_t self = pthread_self();
+	pthread_t self = __pthread_self();
 	locale_t old = self->locale;
 	if (l) self->locale = l;
 	return old;

src/stdio/ftrylockfile.c

@@ -4,7 +4,7 @@
 
 int ftrylockfile(FILE *f)
 {
-	int tid = pthread_self()->tid;
+	int tid = __pthread_self()->tid;
 	if (f->lock == tid) {
 		if (f->lockcount == LONG_MAX)
 			return -1;

src/thread/cancel_impl.c

@@ -58,7 +58,7 @@ static void cancel_handler(int sig, siginfo_t *si, void *ctx)
 void __testcancel()
 {
 	if (!libc.has_thread_pointer) return;
-	pthread_t self = pthread_self();
+	pthread_t self = __pthread_self();
 	if (self->cancel && !self->canceldisable)
 		__cancel();
 }

src/thread/pthread_cond_broadcast.c

@@ -28,7 +28,7 @@ int pthread_cond_broadcast(pthread_cond_t *c)
 	/* Perform the futex requeue, waking one waiter unless we know
 	 * that the calling thread holds the mutex. */
 	__syscall(SYS_futex, &c->_c_seq, FUTEX_REQUEUE,
-		!m->_m_type || (m->_m_lock&INT_MAX)!=pthread_self()->tid,
+		!m->_m_type || (m->_m_lock&INT_MAX)!=__pthread_self()->tid,
 		INT_MAX, &m->_m_lock);
 
 out:

src/thread/pthread_cond_timedwait.c

@@ -41,7 +41,7 @@ int pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restrict
 	struct cm cm = { .c=c, .m=m };
 	int r, e=0, seq;
 
-	if (m->_m_type && (m->_m_lock&INT_MAX) != pthread_self()->tid)
+	if (m->_m_type && (m->_m_lock&INT_MAX) != __pthread_self()->tid)
 		return EPERM;
 
 	if (ts && ts->tv_nsec >= 1000000000UL)

src/thread/pthread_create.c

@@ -13,7 +13,7 @@ weak_alias(dummy_0, __pthread_tsd_run_dtors);
 
 _Noreturn void pthread_exit(void *result)
 {
-	pthread_t self = pthread_self();
+	pthread_t self = __pthread_self();
 	sigset_t set;
 
 	self->result = result;
@@ -78,7 +78,7 @@ _Noreturn void pthread_exit(void *result)
 void __do_cleanup_push(struct __ptcb *cb)
 {
 	if (!libc.has_thread_pointer) return;
-	struct pthread *self = pthread_self();
+	struct pthread *self = __pthread_self();
 	cb->__next = self->cancelbuf;
 	self->cancelbuf = cb;
 }

src/thread/pthread_mutex_consistent.c

@@ -3,7 +3,7 @@
 int pthread_mutex_consistent(pthread_mutex_t *m)
 {
 	if (m->_m_type < 8) return EINVAL;
-	if ((m->_m_lock & 0x3fffffff) != pthread_self()->tid)
+	if ((m->_m_lock & 0x3fffffff) != __pthread_self()->tid)
 		return EPERM;
 	m->_m_type -= 8;
 	return 0;

src/thread/pthread_mutex_timedlock.c

@@ -10,7 +10,7 @@ int pthread_mutex_timedlock(pthread_mutex_t *restrict m, const struct timespec *
 	while ((r=pthread_mutex_trylock(m)) == EBUSY) {
 		if (!(r=m->_m_lock) || (r&0x40000000)) continue;
 		if ((m->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK
-		 && (r&0x1fffffff) == pthread_self()->tid)
+		 && (r&0x1fffffff) == __pthread_self()->tid)
 			return EDEADLK;
 
 		a_inc(&m->_m_waiters);

src/thread/pthread_mutex_trylock.c

@@ -8,7 +8,7 @@ int pthread_mutex_trylock(pthread_mutex_t *m)
 	if (m->_m_type == PTHREAD_MUTEX_NORMAL)
 		return a_cas(&m->_m_lock, 0, EBUSY) & EBUSY;
 
-	self = pthread_self();
+	self = __pthread_self();
 	tid = self->tid;
 
 	if (m->_m_type >= 4) {

src/thread/pthread_mutex_unlock.c

@@ -13,7 +13,7 @@ int pthread_mutex_unlock(pthread_mutex_t *m)
 	if (m->_m_type != PTHREAD_MUTEX_NORMAL) {
 		if (!m->_m_lock)
 			return EPERM;
-		self = pthread_self();
+		self = __pthread_self();
 		if ((m->_m_lock&0x1fffffff) != self->tid)
 			return EPERM;
 		if ((m->_m_type&3) == PTHREAD_MUTEX_RECURSIVE && m->_m_count)

src/thread/pthread_setcanceltype.c

@@ -2,7 +2,7 @@
 
 int pthread_setcanceltype(int new, int *old)
 {
-	struct pthread *self = pthread_self();
+	struct pthread *self = __pthread_self();
 	if (new > 1U) return EINVAL;
 	if (old) *old = self->cancelasync;
 	self->cancelasync = new;