# define PTHREAD_MUTEX_LOCK ___pthread_mutex_lock
PTHREAD_MUTEX_LOCK (pthread_mutex_t *mutex)
{
/* See concurrency notes regarding mutex type which is loaded from __kind
in struct __pthread_mutex_s in sysdeps/nptl/bits/thread-shared-types.h. */
unsigned int type = PTHREAD_MUTEX_TYPE_ELISION (mutex);
LIBC_PROBE (mutex_entry, 1, mutex);
if (__builtin_expect (type & ~(PTHREAD_MUTEX_KIND_MASK_NP
| PTHREAD_MUTEX_ELISION_FLAGS_NP), 0))
return __pthread_mutex_lock_full (mutex);
if (__glibc_likely (type == PTHREAD_MUTEX_TIMED_NP))
{
FORCE_ELISION (mutex, goto elision);
simple:
/* Normal mutex. */
LLL_MUTEX_LOCK_OPTIMIZED (mutex);
assert (mutex->__data.__owner == 0);
}
#if ENABLE_ELISION_SUPPORT
else if (__glibc_likely (type == PTHREAD_MUTEX_TIMED_ELISION_NP))
{
elision: __attribute__((unused))
/* This case can never happen on a system without elision,
as the mutex type initialization functions will not
allow to set the elision flags. */
/* Don't record owner or users for elision case. This is a
tail call. */
return LLL_MUTEX_LOCK_ELISION (mutex);
}
#endif
else if (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex)
== PTHREAD_MUTEX_RECURSIVE_NP, 1))
{
/* Recursive mutex. */
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
/* Check whether we already hold the mutex. */
if (mutex->__data.__owner == id)
{
/* Just bump the counter. */
if (__glibc_unlikely (mutex->__data.__count + 1 == 0))
/* Overflow of the counter. */
return EAGAIN;
++mutex->__data.__count;
return 0;
}
/* We have to get the mutex. */
LLL_MUTEX_LOCK_OPTIMIZED (mutex);
assert (mutex->__data.__owner == 0);
mutex->__data.__count = 1;
}
else if (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex)
== PTHREAD_MUTEX_ADAPTIVE_NP, 1))
{
if (LLL_MUTEX_TRYLOCK (mutex) != 0)
{
int cnt = 0;
int max_cnt = MIN (max_adaptive_count (),
mutex->__data.__spins * 2 + 10);
int spin_count, exp_backoff = 1;
unsigned int jitter = get_jitter ();
do
{
/* In each loop, spin count is exponential backoff plus
random jitter, random range is [0, exp_backoff-1]. */
spin_count = exp_backoff + (jitter & (exp_backoff - 1));
cnt += spin_count;
if (cnt >= max_cnt)
{
/* If cnt exceeds max spin count, just go to wait
queue. */
LLL_MUTEX_LOCK (mutex);
break;
}
do
atomic_spin_nop ();
while (--spin_count > 0);
/* Prepare for next loop. */
exp_backoff = get_next_backoff (exp_backoff);
}
while (LLL_MUTEX_READ_LOCK (mutex) != 0
|| LLL_MUTEX_TRYLOCK (mutex) != 0);
mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;
}
assert (mutex->__data.__owner == 0);
}
else
{
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
assert (PTHREAD_MUTEX_TYPE (mutex) == PTHREAD_MUTEX_ERRORCHECK_NP);
/* Check whether we already hold the mutex. */
if (__glibc_unlikely (mutex->__data.__owner == id))
return EDEADLK;
goto simple;
}
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
/* Record the ownership. */
mutex->__data.__owner = id;
#ifndef NO_INCR
++mutex->__data.__nusers;
#endif
LIBC_PROBE (mutex_acquired, 1, mutex);
return 0;
}
# define LLL_MUTEX_LOCK(mutex) \
lll_lock ((mutex)->__data.__lock, PTHREAD_MUTEX_PSHARED (mutex))
/* This is an expression rather than a statement even though its value is
void, so that it can be used in a comma expression or as an expression
that's cast to void. */
/* The inner conditional compiles to a call to __lll_lock_wait_private if
private is known at compile time to be LLL_PRIVATE, and to a call to
__lll_lock_wait otherwise. */
/* If FUTEX is 0 (not acquired), set to 1 (acquired with no waiters) and
return. Otherwise, ensure that it is >1 (acquired, possibly with waiters)
and then block until we acquire the lock, at which point FUTEX will still be
>1. The lock is always acquired on return. */
#define __lll_lock(futex, private) \
((void) \
({ \
int *__futex = (futex); \
if (__glibc_unlikely \
(atomic_compare_and_exchange_bool_acq (__futex, 1, 0))) \
{ \
if (__builtin_constant_p (private) && (private) == LLL_PRIVATE) \
__lll_lock_wait_private (__futex); \
else \
__lll_lock_wait (__futex, private); \
} \
}))
#define lll_lock(futex, private) \
__lll_lock (&(futex), private)
void
__lll_lock_wait (int *futex, int private)
{
if (atomic_load_relaxed (futex) == 2)
goto futex;
while (atomic_exchange_acquire (futex, 2) != 0)
{
futex:
LIBC_PROBE (lll_lock_wait, 1, futex);
futex_wait ((unsigned int *) futex, 2, private); /* Wait if *futex == 2. */
}
}
libc_hidden_def (__lll_lock_wait)
static int
__pthread_mutex_lock_full (pthread_mutex_t *mutex)
{
int oldval;
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
switch (PTHREAD_MUTEX_TYPE (mutex))
{
case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
&mutex->__data.__list.__next);
/* We need to set op_pending before starting the operation. Also
see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
oldval = mutex->__data.__lock;
/* This is set to FUTEX_WAITERS iff we might have shared the
FUTEX_WAITERS flag with other threads, and therefore need to keep it
set to avoid lost wake-ups. We have the same requirement in the
simple mutex algorithm.
We start with value zero for a normal mutex, and FUTEX_WAITERS if we
are building the special case mutexes for use from within condition
variables. */
unsigned int assume_other_futex_waiters = LLL_ROBUST_MUTEX_LOCK_MODIFIER;
while (1)
{
/* Try to acquire the lock through a CAS from 0 (not acquired) to
our TID | assume_other_futex_waiters. */
if (__glibc_likely (oldval == 0))
{
oldval
= atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
id | assume_other_futex_waiters, 0);
if (__glibc_likely (oldval == 0))
break;
}
if ((oldval & FUTEX_OWNER_DIED) != 0)
{
/* The previous owner died. Try locking the mutex. */
int newval = id;
#ifdef NO_INCR
/* We are not taking assume_other_futex_waiters into accoount
here simply because we'll set FUTEX_WAITERS anyway. */
newval |= FUTEX_WAITERS;
#else
newval |= (oldval & FUTEX_WAITERS) | assume_other_futex_waiters;
#endif
newval
= atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
newval, oldval);
if (newval != oldval)
{
oldval = newval;
continue;
}
/* We got the mutex. */
mutex->__data.__count = 1;
/* But it is inconsistent unless marked otherwise. */
mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
/* We must not enqueue the mutex before we have acquired it.
Also see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
ENQUEUE_MUTEX (mutex);
/* We need to clear op_pending after we enqueue the mutex. */
__asm ("" ::: "memory");
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
/* Note that we deliberately exit here. If we fall
through to the end of the function __nusers would be
incremented which is not correct because the old
owner has to be discounted. If we are not supposed
to increment __nusers we actually have to decrement
it here. */
#ifdef NO_INCR
--mutex->__data.__nusers;
#endif
return EOWNERDEAD;
}
/* Check whether we already hold the mutex. */
if (__glibc_unlikely ((oldval & FUTEX_TID_MASK) == id))
{
int kind = PTHREAD_MUTEX_TYPE (mutex);
if (kind == PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP)
{
/* We do not need to ensure ordering wrt another memory
access. Also see comments at ENQUEUE_MUTEX. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
NULL);
return EDEADLK;
}
if (kind == PTHREAD_MUTEX_ROBUST_RECURSIVE_NP)
{
/* We do not need to ensure ordering wrt another memory
access. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
NULL);
/* Just bump the counter. */
if (__glibc_unlikely (mutex->__data.__count + 1 == 0))
/* Overflow of the counter. */
return EAGAIN;
++mutex->__data.__count;
return 0;
}
}
/* We cannot acquire the mutex nor has its owner died. Thus, try
to block using futexes. Set FUTEX_WAITERS if necessary so that
other threads are aware that there are potentially threads
blocked on the futex. Restart if oldval changed in the
meantime. */
if ((oldval & FUTEX_WAITERS) == 0)
{
int val = atomic_compare_and_exchange_val_acq
(&mutex->__data.__lock, oldval | FUTEX_WAITERS, oldval);
if (val != oldval)
{
oldval = val;
continue;
}
oldval |= FUTEX_WAITERS;
}
/* It is now possible that we share the FUTEX_WAITERS flag with
another thread; therefore, update assume_other_futex_waiters so
that we do not forget about this when handling other cases
above and thus do not cause lost wake-ups. */
assume_other_futex_waiters |= FUTEX_WAITERS;
/* Block using the futex and reload current lock value. */
futex_wait ((unsigned int *) &mutex->__data.__lock, oldval,
PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
oldval = mutex->__data.__lock;
}
/* We have acquired the mutex; check if it is still consistent. */
if (__builtin_expect (mutex->__data.__owner
== PTHREAD_MUTEX_NOTRECOVERABLE, 0))
{
/* This mutex is now not recoverable. */
mutex->__data.__count = 0;
int private = PTHREAD_ROBUST_MUTEX_PSHARED (mutex);
lll_unlock (mutex->__data.__lock, private);
/* FIXME This violates the mutex destruction requirements. See
__pthread_mutex_unlock_full. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
return ENOTRECOVERABLE;
}
mutex->__data.__count = 1;
/* We must not enqueue the mutex before we have acquired it.
Also see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
ENQUEUE_MUTEX (mutex);
/* We need to clear op_pending after we enqueue the mutex. */
__asm ("" ::: "memory");
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
break;
/* The PI support requires the Linux futex system call. If that's not
available, pthread_mutex_init should never have allowed the type to
be set. So it will get the default case for an invalid type. */
#ifdef __NR_futex
case PTHREAD_MUTEX_PI_RECURSIVE_NP:
case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
case PTHREAD_MUTEX_PI_NORMAL_NP:
case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
{
int kind, robust;
{
/* See concurrency notes regarding __kind in struct __pthread_mutex_s
in sysdeps/nptl/bits/thread-shared-types.h. */
int mutex_kind = atomic_load_relaxed (&(mutex->__data.__kind));
kind = mutex_kind & PTHREAD_MUTEX_KIND_MASK_NP;
robust = mutex_kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;
}
if (robust)
{
/* Note: robust PI futexes are signaled by setting bit 0. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
(void *) (((uintptr_t) &mutex->__data.__list.__next)
| 1));
/* We need to set op_pending before starting the operation. Also
see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
}
oldval = mutex->__data.__lock;
/* Check whether we already hold the mutex. */
if (__glibc_unlikely ((oldval & FUTEX_TID_MASK) == id))
{
if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
{
/* We do not need to ensure ordering wrt another memory
access. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
return EDEADLK;
}
if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
{
/* We do not need to ensure ordering wrt another memory
access. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
/* Just bump the counter. */
if (__glibc_unlikely (mutex->__data.__count + 1 == 0))
/* Overflow of the counter. */
return EAGAIN;
++mutex->__data.__count;
return 0;
}
}
int newval = id;
# ifdef NO_INCR
newval |= FUTEX_WAITERS;
# endif
oldval = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
newval, 0);
if (oldval != 0)
{
/* The mutex is locked. The kernel will now take care of
everything. */
int private = (robust
? PTHREAD_ROBUST_MUTEX_PSHARED (mutex)
: PTHREAD_MUTEX_PSHARED (mutex));
int e = __futex_lock_pi64 (&mutex->__data.__lock, 0 /* ununsed */,
NULL, private);
if (e == ESRCH || e == EDEADLK)
{
assert (e != EDEADLK
|| (kind != PTHREAD_MUTEX_ERRORCHECK_NP
&& kind != PTHREAD_MUTEX_RECURSIVE_NP));
/* ESRCH can happen only for non-robust PI mutexes where
the owner of the lock died. */
assert (e != ESRCH || !robust);
/* Delay the thread indefinitely. */
while (1)
__futex_abstimed_wait64 (&(unsigned int){0}, 0,
0 /* ignored */, NULL, private);
}
oldval = mutex->__data.__lock;
assert (robust || (oldval & FUTEX_OWNER_DIED) == 0);
}
if (__glibc_unlikely (oldval & FUTEX_OWNER_DIED))
{
atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);
/* We got the mutex. */
mutex->__data.__count = 1;
/* But it is inconsistent unless marked otherwise. */
mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
/* We must not enqueue the mutex before we have acquired it.
Also see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
ENQUEUE_MUTEX_PI (mutex);
/* We need to clear op_pending after we enqueue the mutex. */
__asm ("" ::: "memory");
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
/* Note that we deliberately exit here. If we fall
through to the end of the function __nusers would be
incremented which is not correct because the old owner
has to be discounted. If we are not supposed to
increment __nusers we actually have to decrement it here. */
# ifdef NO_INCR
--mutex->__data.__nusers;
# endif
return EOWNERDEAD;
}
if (robust
&& __builtin_expect (mutex->__data.__owner
== PTHREAD_MUTEX_NOTRECOVERABLE, 0))
{
/* This mutex is now not recoverable. */
mutex->__data.__count = 0;
futex_unlock_pi ((unsigned int *) &mutex->__data.__lock,
PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
/* To the kernel, this will be visible after the kernel has
acquired the mutex in the syscall. */
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
return ENOTRECOVERABLE;
}
mutex->__data.__count = 1;
if (robust)
{
/* We must not enqueue the mutex before we have acquired it.
Also see comments at ENQUEUE_MUTEX. */
__asm ("" ::: "memory");
ENQUEUE_MUTEX_PI (mutex);
/* We need to clear op_pending after we enqueue the mutex. */
__asm ("" ::: "memory");
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
}
}
break;
#endif /* __NR_futex. */
case PTHREAD_MUTEX_PP_RECURSIVE_NP:
case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
case PTHREAD_MUTEX_PP_NORMAL_NP:
case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
{
/* See concurrency notes regarding __kind in struct __pthread_mutex_s
in sysdeps/nptl/bits/thread-shared-types.h. */
int kind = atomic_load_relaxed (&(mutex->__data.__kind))
& PTHREAD_MUTEX_KIND_MASK_NP;
oldval = mutex->__data.__lock;
/* Check whether we already hold the mutex. */
if (mutex->__data.__owner == id)
{
if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
return EDEADLK;
if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
{
/* Just bump the counter. */
if (__glibc_unlikely (mutex->__data.__count + 1 == 0))
/* Overflow of the counter. */
return EAGAIN;
++mutex->__data.__count;
return 0;
}
}
int oldprio = -1, ceilval;
do
{
int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
>> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
if (__pthread_current_priority () > ceiling)
{
if (oldprio != -1)
__pthread_tpp_change_priority (oldprio, -1);
return EINVAL;
}
int retval = __pthread_tpp_change_priority (oldprio, ceiling);
if (retval)
return retval;
ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
oldprio = ceiling;
oldval
= atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
#ifdef NO_INCR
ceilval | 2,
#else
ceilval | 1,
#endif
ceilval);
if (oldval == ceilval)
break;
do
{
oldval
= atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
ceilval | 2,
ceilval | 1);
if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
break;
if (oldval != ceilval)
futex_wait ((unsigned int * ) &mutex->__data.__lock,
ceilval | 2,
PTHREAD_MUTEX_PSHARED (mutex));
}
while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
ceilval | 2, ceilval)
!= ceilval);
}
while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);
assert (mutex->__data.__owner == 0);
mutex->__data.__count = 1;
}
break;
default:
/* Correct code cannot set any other type. */
return EINVAL;
}
/* Record the ownership. */
mutex->__data.__owner = id;
#ifndef NO_INCR
++mutex->__data.__nusers;
#endif
LIBC_PROBE (mutex_acquired, 1, mutex);
return 0;
}
00010548 <__pthread_mutex_lock_full>:
10548: 68c3 ldr r3, [r0, #12]
1054a: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
1054e: ee1d 5f70 mrc 15, 0, r5, cr13, cr0, {3}
10552: f5a5 6698 sub.w r6, r5, #1216 ; 0x4c0
10556: b0a0 sub sp, #128 ; 0x80
10558: f003 027f and.w r2, r3, #127 ; 0x7f
1055c: 4604 mov r4, r0
1055e: 3a10 subs r2, #16
10560: f8d6 9068 ldr.w r9, [r6, #104] ; 0x68
10564: 2a33 cmp r2, #51 ; 0x33
10566: f200 8115 bhi.w 10794 <__pthread_mutex_lock_full+0x24c>
1056a: e8df f012 tbh [pc, r2, lsl #1]
1056e: 00e6 .short 0x00e6
10570: 00e600e6 .word 0x00e600e6
10574: 011300e6 .word 0x011300e6
10578: 01130113 .word 0x01130113
1057c: 01130113 .word 0x01130113
10580: 01130113 .word 0x01130113
10584: 01130113 .word 0x01130113
10588: 01130113 .word 0x01130113
1058c: 008c0113 .word 0x008c0113
10590: 008c008c .word 0x008c008c
10594: 0113008c .word 0x0113008c
10598: 01130113 .word 0x01130113
1059c: 01130113 .word 0x01130113
105a0: 01130113 .word 0x01130113
105a4: 01130113 .word 0x01130113
105a8: 01130113 .word 0x01130113
105ac: 008c0113 .word 0x008c0113
105b0: 008c008c .word 0x008c008c
105b4: 0113008c .word 0x0113008c
105b8: 01130113 .word 0x01130113
105bc: 01130113 .word 0x01130113
105c0: 01130113 .word 0x01130113
105c4: 01130113 .word 0x01130113
105c8: 01130113 .word 0x01130113
105cc: 00340113 .word 0x00340113
105d0: 00340034 .word 0x00340034
105d4: 0034 .short 0x0034
105d6: 6882 ldr r2, [r0, #8]
105d8: 6801 ldr r1, [r0, #0]
105da: 454a cmp r2, r9
105dc: f000 8101 beq.w 107e2 <__pthread_mutex_lock_full+0x29a>
105e0: f04f 0800 mov.w r8, #0
105e4: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff
105e8: f6cf 78f8 movt r8, #65528 ; 0xfff8
105ec: ea4f 4ad1 mov.w sl, r1, lsr #19
105f0: f000 feda bl 113a8 <__pthread_current_priority>
105f4: 4550 cmp r0, sl
105f6: f300 8121 bgt.w 1083c <__pthread_mutex_lock_full+0x2f4>
105fa: 4628 mov r0, r5
105fc: 4651 mov r1, sl
105fe: f000 fd81 bl 11104 <__pthread_tpp_change_priority>
10602: 2800 cmp r0, #0
10604: f040 80c3 bne.w 1078e <__pthread_mutex_lock_full+0x246>
10608: ea4f 45ca mov.w r5, sl, lsl #19
1060c: f045 0701 orr.w r7, r5, #1
10610: e854 3f00 ldrex r3, [r4]
10614: 42ab cmp r3, r5
10616: d105 bne.n 10624 <__pthread_mutex_lock_full+0xdc>
10618: e844 7200 strex r2, r7, [r4]
1061c: 2a00 cmp r2, #0
1061e: d1f7 bne.n 10610 <__pthread_mutex_lock_full+0xc8>
10620: f3bf 8f5b dmb ish
10624: 429d cmp r5, r3
10626: f000 80b9 beq.w 1079c <__pthread_mutex_lock_full+0x254>
1062a: f045 0602 orr.w r6, r5, #2
1062e: e019 b.n 10664 <__pthread_mutex_lock_full+0x11c>
10630: 429d cmp r5, r3
10632: d00a beq.n 1064a <__pthread_mutex_lock_full+0x102>
10634: 68e1 ldr r1, [r4, #12]
10636: 4620 mov r0, r4
10638: 4632 mov r2, r6
1063a: 2300 movs r3, #0
1063c: f04f 0cf0 mov.w ip, #240 ; 0xf0
10640: 43c9 mvns r1, r1
10642: f001 0180 and.w r1, r1, #128 ; 0x80
10646: f004 ffa3 bl 15590 <__libc_do_syscall>
1064a: e854 3f00 ldrex r3, [r4]
1064e: 42ab cmp r3, r5
10650: d105 bne.n 1065e <__pthread_mutex_lock_full+0x116>
10652: e844 6200 strex r2, r6, [r4]
10656: 2a00 cmp r2, #0
10658: d1f7 bne.n 1064a <__pthread_mutex_lock_full+0x102>
1065a: f3bf 8f5b dmb ish
1065e: 429d cmp r5, r3
10660: f000 809c beq.w 1079c <__pthread_mutex_lock_full+0x254>
10664: e854 3f00 ldrex r3, [r4]
10668: 42bb cmp r3, r7
1066a: d105 bne.n 10678 <__pthread_mutex_lock_full+0x130>
1066c: e844 6200 strex r2, r6, [r4]
10670: 2a00 cmp r2, #0
10672: d1f7 bne.n 10664 <__pthread_mutex_lock_full+0x11c>
10674: f3bf 8f5b dmb ish
10678: ea03 0208 and.w r2, r3, r8
1067c: 4619 mov r1, r3
1067e: 42aa cmp r2, r5
10680: d0d6 beq.n 10630 <__pthread_mutex_lock_full+0xe8>
10682: 4655 mov r5, sl
10684: e7b2 b.n 105ec <__pthread_mutex_lock_full+0xa4>
10686: f013 0710 ands.w r7, r3, #16
1068a: f003 0803 and.w r8, r3, #3
1068e: f040 80a2 bne.w 107d6 <__pthread_mutex_lock_full+0x28e>
10692: 6823 ldr r3, [r4, #0]
10694: f023 4340 bic.w r3, r3, #3221225472 ; 0xc0000000
10698: 454b cmp r3, r9
1069a: f000 8138 beq.w 1090e <__pthread_mutex_lock_full+0x3c6>
1069e: e854 3f00 ldrex r3, [r4]
106a2: 2b00 cmp r3, #0
106a4: d105 bne.n 106b2 <__pthread_mutex_lock_full+0x16a>
106a6: e844 9200 strex r2, r9, [r4]
106aa: 2a00 cmp r2, #0
106ac: d1f7 bne.n 1069e <__pthread_mutex_lock_full+0x156>
106ae: f3bf 8f5b dmb ish
106b2: 2b00 cmp r3, #0
106b4: d079 beq.n 107aa <__pthread_mutex_lock_full+0x262>
106b6: 2106 movs r1, #6
106b8: b927 cbnz r7, 106c4 <__pthread_mutex_lock_full+0x17c>
106ba: 68e3 ldr r3, [r4, #12]
106bc: f003 0380 and.w r3, r3, #128 ; 0x80
106c0: f083 0186 eor.w r1, r3, #134 ; 0x86
106c4: 4620 mov r0, r4
106c6: 2201 movs r2, #1
106c8: 2300 movs r3, #0
106ca: f04f 0cf0 mov.w ip, #240 ; 0xf0
106ce: f004 ff5f bl 15590 <__libc_do_syscall>
106d2: f510 5f80 cmn.w r0, #4096 ; 0x1000
106d6: f240 809a bls.w 1080e <__pthread_mutex_lock_full+0x2c6>
106da: f020 0320 bic.w r3, r0, #32
106de: 3323 adds r3, #35 ; 0x23
106e0: f040 8095 bne.w 1080e <__pthread_mutex_lock_full+0x2c6>
106e4: f110 0f23 cmn.w r0, #35 ; 0x23
106e8: f000 817a beq.w 109e0 <__pthread_mutex_lock_full+0x498>
106ec: 1cc3 adds r3, r0, #3
106ee: bf18 it ne
106f0: 2301 movne r3, #1
106f2: 2f00 cmp r7, #0
106f4: bf08 it eq
106f6: 2301 moveq r3, #1
106f8: 2b00 cmp r3, #0
106fa: f000 8161 beq.w 109c0 <__pthread_mutex_lock_full+0x478>
106fe: 4cc3 ldr r4, [pc, #780] ; (10a0c <__pthread_mutex_lock_full+0x4c4>)
10700: 4ec3 ldr r6, [pc, #780] ; (10a10 <__pthread_mutex_lock_full+0x4c8>)
10702: 2000 movs r0, #0
10704: 466a mov r2, sp
10706: 4601 mov r1, r0
10708: 2308 movs r3, #8
1070a: f04f 0caf mov.w ip, #175 ; 0xaf
1070e: f004 ff3f bl 15590 <__libc_do_syscall>
10712: f510 5f80 cmn.w r0, #4096 ; 0x1000
10716: d874 bhi.n 10802 <__pthread_mutex_lock_full+0x2ba>
10718: 2800 cmp r0, #0
1071a: d1f2 bne.n 10702 <__pthread_mutex_lock_full+0x1ba>
1071c: 4619 mov r1, r3
1071e: 4668 mov r0, sp
10720: f04f 0cb3 mov.w ip, #179 ; 0xb3
10724: f004 ff34 bl 15590 <__libc_do_syscall>
10728: f510 5f80 cmn.w r0, #4096 ; 0x1000
1072c: d9e9 bls.n 10702 <__pthread_mutex_lock_full+0x1ba>
1072e: 4633 mov r3, r6
10730: 4240 negs r0, r0
10732: 447b add r3, pc
10734: 681b ldr r3, [r3, #0]
10736: 50e8 str r0, [r5, r3]
10738: e7e3 b.n 10702 <__pthread_mutex_lock_full+0x1ba>
1073a: f100 0514 add.w r5, r0, #20
1073e: 67b5 str r5, [r6, #120] ; 0x78
10740: 6803 ldr r3, [r0, #0]
10742: 2100 movs r1, #0
10744: 2b00 cmp r3, #0
10746: f040 8082 bne.w 1084e <__pthread_mutex_lock_full+0x306>
1074a: ea49 0001 orr.w r0, r9, r1
1074e: e854 2f00 ldrex r2, [r4]
10752: 2a00 cmp r2, #0
10754: d105 bne.n 10762 <__pthread_mutex_lock_full+0x21a>
10756: e844 0700 strex r7, r0, [r4]
1075a: 2f00 cmp r7, #0
1075c: d1f7 bne.n 1074e <__pthread_mutex_lock_full+0x206>
1075e: f3bf 8f5b dmb ish
10762: 2a00 cmp r2, #0
10764: d174 bne.n 10850 <__pthread_mutex_lock_full+0x308>
10766: 68a1 ldr r1, [r4, #8]
10768: f64f 72fe movw r2, #65534 ; 0xfffe
1076c: f6c7 72ff movt r2, #32767 ; 0x7fff
10770: 4291 cmp r1, r2
10772: f000 80e2 beq.w 1093a <__pthread_mutex_lock_full+0x3f2>
10776: 2201 movs r2, #1
10778: 6062 str r2, [r4, #4]
1077a: 6f32 ldr r2, [r6, #112] ; 0x70
1077c: 6162 str r2, [r4, #20]
1077e: 6735 str r5, [r6, #112] ; 0x70
10780: 67b3 str r3, [r6, #120] ; 0x78
10782: 6923 ldr r3, [r4, #16]
10784: 2000 movs r0, #0
10786: f8c4 9008 str.w r9, [r4, #8]
1078a: 3301 adds r3, #1
1078c: 6123 str r3, [r4, #16]
1078e: b020 add sp, #128 ; 0x80
10790: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
10794: 2016 movs r0, #22
10796: b020 add sp, #128 ; 0x80
10798: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
1079c: 68a3 ldr r3, [r4, #8]
1079e: 2b00 cmp r3, #0
107a0: f040 80e6 bne.w 10970 <__pthread_mutex_lock_full+0x428>
107a4: 2301 movs r3, #1
107a6: 6063 str r3, [r4, #4]
107a8: e7eb b.n 10782 <__pthread_mutex_lock_full+0x23a>
107aa: 2f00 cmp r7, #0
107ac: d0fa beq.n 107a4 <__pthread_mutex_lock_full+0x25c>
107ae: 68a2 ldr r2, [r4, #8]
107b0: f64f 73fe movw r3, #65534 ; 0xfffe
107b4: f6c7 73ff movt r3, #32767 ; 0x7fff
107b8: 429a cmp r2, r3
107ba: f000 80cd beq.w 10958 <__pthread_mutex_lock_full+0x410>
107be: 2301 movs r3, #1
107c0: 6063 str r3, [r4, #4]
107c2: 6f32 ldr r2, [r6, #112] ; 0x70
107c4: 4623 mov r3, r4
107c6: f843 2f14 str.w r2, [r3, #20]!
107ca: f043 0301 orr.w r3, r3, #1
107ce: 6733 str r3, [r6, #112] ; 0x70
107d0: 2300 movs r3, #0
107d2: 67b3 str r3, [r6, #120] ; 0x78
107d4: e7d5 b.n 10782 <__pthread_mutex_lock_full+0x23a>
107d6: f100 0314 add.w r3, r0, #20
107da: f043 0301 orr.w r3, r3, #1
107de: 67b3 str r3, [r6, #120] ; 0x78
107e0: e757 b.n 10692 <__pthread_mutex_lock_full+0x14a>
107e2: f003 0303 and.w r3, r3, #3
107e6: 2b02 cmp r3, #2
107e8: f000 80a5 beq.w 10936 <__pthread_mutex_lock_full+0x3ee>
107ec: 2b01 cmp r3, #1
107ee: f47f aef7 bne.w 105e0 <__pthread_mutex_lock_full+0x98>
107f2: 6843 ldr r3, [r0, #4]
107f4: 1c5a adds r2, r3, #1
107f6: f000 80de beq.w 109b6 <__pthread_mutex_lock_full+0x46e>
107fa: 3301 adds r3, #1
107fc: 2000 movs r0, #0
107fe: 6063 str r3, [r4, #4]
10800: e7c5 b.n 1078e <__pthread_mutex_lock_full+0x246>
10802: 4623 mov r3, r4
10804: 4240 negs r0, r0
10806: 447b add r3, pc
10808: 681b ldr r3, [r3, #0]
1080a: 50e8 str r0, [r5, r3]
1080c: e779 b.n 10702 <__pthread_mutex_lock_full+0x1ba>
1080e: 6823 ldr r3, [r4, #0]
10810: f003 4380 and.w r3, r3, #1073741824 ; 0x40000000
10814: 2f00 cmp r7, #0
10816: d13c bne.n 10892 <__pthread_mutex_lock_full+0x34a>
10818: 2b00 cmp r3, #0
1081a: d0c3 beq.n 107a4 <__pthread_mutex_lock_full+0x25c>
1081c: f248 53c0 movw r3, #34240 ; 0x85c0
10820: f248 4170 movw r1, #33904 ; 0x8470
10824: f248 503c movw r0, #34108 ; 0x853c
10828: f2c0 0305 movt r3, #5
1082c: f2c0 0105 movt r1, #5
10830: f2c0 0005 movt r0, #5
10834: f44f 72da mov.w r2, #436 ; 0x1b4
10838: f004 ff34 bl 156a4 <__assert_fail>
1083c: 1c6b adds r3, r5, #1
1083e: d0a9 beq.n 10794 <__pthread_mutex_lock_full+0x24c>
10840: 4628 mov r0, r5
10842: f04f 31ff mov.w r1, #4294967295 ; 0xffffffff
10846: f000 fc5d bl 11104 <__pthread_tpp_change_priority>
1084a: 2016 movs r0, #22
1084c: e79f b.n 1078e <__pthread_mutex_lock_full+0x246>
1084e: 461a mov r2, r3
10850: f012 4080 ands.w r0, r2, #1073741824 ; 0x40000000
10854: d03b beq.n 108ce <__pthread_mutex_lock_full+0x386>
10856: f002 4000 and.w r0, r2, #2147483648 ; 0x80000000
1085a: ea49 0301 orr.w r3, r9, r1
1085e: 4318 orrs r0, r3
10860: e854 3f00 ldrex r3, [r4]
10864: 4293 cmp r3, r2
10866: d105 bne.n 10874 <__pthread_mutex_lock_full+0x32c>
10868: e844 0700 strex r7, r0, [r4]
1086c: 2f00 cmp r7, #0
1086e: d1f7 bne.n 10860 <__pthread_mutex_lock_full+0x318>
10870: f3bf 8f5b dmb ish
10874: 429a cmp r2, r3
10876: f47f af65 bne.w 10744 <__pthread_mutex_lock_full+0x1fc>
1087a: 2201 movs r2, #1
1087c: f06f 4300 mvn.w r3, #2147483648 ; 0x80000000
10880: e9c4 2301 strd r2, r3, [r4, #4]
10884: 6f33 ldr r3, [r6, #112] ; 0x70
10886: 6163 str r3, [r4, #20]
10888: 6735 str r5, [r6, #112] ; 0x70
1088a: 2300 movs r3, #0
1088c: 2082 movs r0, #130 ; 0x82
1088e: 67b3 str r3, [r6, #120] ; 0x78
10890: e77d b.n 1078e <__pthread_mutex_lock_full+0x246>
10892: 2b00 cmp r3, #0
10894: d08b beq.n 107ae <__pthread_mutex_lock_full+0x266>
10896: 6823 ldr r3, [r4, #0]
10898: f023 4280 bic.w r2, r3, #1073741824 ; 0x40000000
1089c: e854 1f00 ldrex r1, [r4]
108a0: 4299 cmp r1, r3
108a2: d105 bne.n 108b0 <__pthread_mutex_lock_full+0x368>
108a4: e844 2000 strex r0, r2, [r4]
108a8: 2800 cmp r0, #0
108aa: d1f7 bne.n 1089c <__pthread_mutex_lock_full+0x354>
108ac: f3bf 8f5b dmb ish
108b0: d1f1 bne.n 10896 <__pthread_mutex_lock_full+0x34e>
108b2: 2201 movs r2, #1
108b4: f06f 4300 mvn.w r3, #2147483648 ; 0x80000000
108b8: e9c4 2301 strd r2, r3, [r4, #4]
108bc: 6f33 ldr r3, [r6, #112] ; 0x70
108be: f844 3f14 str.w r3, [r4, #20]!
108c2: 4314 orrs r4, r2
108c4: 6734 str r4, [r6, #112] ; 0x70
108c6: 2300 movs r3, #0
108c8: 2082 movs r0, #130 ; 0x82
108ca: 67b3 str r3, [r6, #120] ; 0x78
108cc: e75f b.n 1078e <__pthread_mutex_lock_full+0x246>
108ce: f022 4340 bic.w r3, r2, #3221225472 ; 0xc0000000
108d2: 454b cmp r3, r9
108d4: d064 beq.n 109a0 <__pthread_mutex_lock_full+0x458>
108d6: 2a00 cmp r2, #0
108d8: db0e blt.n 108f8 <__pthread_mutex_lock_full+0x3b0>
108da: f042 4300 orr.w r3, r2, #2147483648 ; 0x80000000
108de: e854 0f00 ldrex r0, [r4]
108e2: 4290 cmp r0, r2
108e4: d105 bne.n 108f2 <__pthread_mutex_lock_full+0x3aa>
108e6: e844 3700 strex r7, r3, [r4]
108ea: 2f00 cmp r7, #0
108ec: d1f7 bne.n 108de <__pthread_mutex_lock_full+0x396>
108ee: f3bf 8f5b dmb ish
108f2: bf08 it eq
108f4: 461a moveq r2, r3
108f6: d108 bne.n 1090a <__pthread_mutex_lock_full+0x3c2>
108f8: 2100 movs r1, #0
108fa: 4620 mov r0, r4
108fc: 460b mov r3, r1
108fe: f04f 0cf0 mov.w ip, #240 ; 0xf0
10902: f004 fe45 bl 15590 <__libc_do_syscall>
10906: f04f 4100 mov.w r1, #2147483648 ; 0x80000000
1090a: 6823 ldr r3, [r4, #0]
1090c: e71a b.n 10744 <__pthread_mutex_lock_full+0x1fc>
1090e: f1b8 0f02 cmp.w r8, #2
10912: bf02 ittt eq
10914: 2300 moveq r3, #0
10916: 2023 moveq r0, #35 ; 0x23
10918: 67b3 streq r3, [r6, #120] ; 0x78
1091a: f43f af38 beq.w 1078e <__pthread_mutex_lock_full+0x246>
1091e: f1b8 0f01 cmp.w r8, #1
10922: f47f aebc bne.w 1069e <__pthread_mutex_lock_full+0x156>
10926: 6863 ldr r3, [r4, #4]
10928: 2000 movs r0, #0
1092a: 67b0 str r0, [r6, #120] ; 0x78
1092c: 1c59 adds r1, r3, #1
1092e: d042 beq.n 109b6 <__pthread_mutex_lock_full+0x46e>
10930: 3301 adds r3, #1
10932: 6063 str r3, [r4, #4]
10934: e72b b.n 1078e <__pthread_mutex_lock_full+0x246>
10936: 2023 movs r0, #35 ; 0x23
10938: e729 b.n 1078e <__pthread_mutex_lock_full+0x246>
1093a: 6063 str r3, [r4, #4]
1093c: f3bf 8f5b dmb ish
10940: e854 2f00 ldrex r2, [r4]
10944: e844 3100 strex r1, r3, [r4]
10948: 2900 cmp r1, #0
1094a: d1f9 bne.n 10940 <__pthread_mutex_lock_full+0x3f8>
1094c: 2a01 cmp r2, #1
1094e: dc1f bgt.n 10990 <__pthread_mutex_lock_full+0x448>
10950: 2300 movs r3, #0
10952: 2083 movs r0, #131 ; 0x83
10954: 67b3 str r3, [r6, #120] ; 0x78
10956: e71a b.n 1078e <__pthread_mutex_lock_full+0x246>
10958: 2200 movs r2, #0
1095a: 4620 mov r0, r4
1095c: 6062 str r2, [r4, #4]
1095e: 4613 mov r3, r2
10960: 2107 movs r1, #7
10962: f04f 0cf0 mov.w ip, #240 ; 0xf0
10966: f004 fe13 bl 15590 <__libc_do_syscall>
1096a: 2083 movs r0, #131 ; 0x83
1096c: 67b2 str r2, [r6, #120] ; 0x78
1096e: e70e b.n 1078e <__pthread_mutex_lock_full+0x246>
10970: f248 53c0 movw r3, #34240 ; 0x85c0
10974: f248 4170 movw r1, #33904 ; 0x8470
10978: f248 5068 movw r0, #34152 ; 0x8568
1097c: f2c0 0305 movt r3, #5
10980: f2c0 0105 movt r1, #5
10984: f2c0 0005 movt r0, #5
10988: f240 2246 movw r2, #582 ; 0x246
1098c: f004 fe8a bl 156a4 <__assert_fail>
10990: 2101 movs r1, #1
10992: 4620 mov r0, r4
10994: 460a mov r2, r1
10996: f04f 0cf0 mov.w ip, #240 ; 0xf0
1099a: f004 fdf9 bl 15590 <__libc_do_syscall>
1099e: e7d7 b.n 10950 <__pthread_mutex_lock_full+0x408>
109a0: 68e3 ldr r3, [r4, #12]
109a2: f003 037f and.w r3, r3, #127 ; 0x7f
109a6: 2b12 cmp r3, #18
109a8: d007 beq.n 109ba <__pthread_mutex_lock_full+0x472>
109aa: 2b11 cmp r3, #17
109ac: d193 bne.n 108d6 <__pthread_mutex_lock_full+0x38e>
109ae: 6863 ldr r3, [r4, #4]
109b0: 67b0 str r0, [r6, #120] ; 0x78
109b2: 1c5d adds r5, r3, #1
109b4: d1bc bne.n 10930 <__pthread_mutex_lock_full+0x3e8>
109b6: 200b movs r0, #11
109b8: e6e9 b.n 1078e <__pthread_mutex_lock_full+0x246>
109ba: 67b0 str r0, [r6, #120] ; 0x78
109bc: 2023 movs r0, #35 ; 0x23
109be: e6e6 b.n 1078e <__pthread_mutex_lock_full+0x246>
109c0: f248 53c0 movw r3, #34240 ; 0x85c0
109c4: f248 4170 movw r1, #33904 ; 0x8470
109c8: f248 5004 movw r0, #34052 ; 0x8504
109cc: f2c0 0305 movt r3, #5
109d0: f2c0 0105 movt r1, #5
109d4: f2c0 0005 movt r0, #5
109d8: f240 12ab movw r2, #427 ; 0x1ab
109dc: f004 fe62 bl 156a4 <__assert_fail>
109e0: f108 38ff add.w r8, r8, #4294967295 ; 0xffffffff
109e4: 4590 cmp r8, r2
109e6: f63f ae8a bhi.w 106fe <__pthread_mutex_lock_full+0x1b6>
109ea: f248 53c0 movw r3, #34240 ; 0x85c0
109ee: f248 4170 movw r1, #33904 ; 0x8470
109f2: f248 4088 movw r0, #33928 ; 0x8488
109f6: f2c0 0305 movt r3, #5
109fa: f2c0 0105 movt r1, #5
109fe: f2c0 0005 movt r0, #5
10a02: f44f 72d4 mov.w r2, #424 ; 0x1a8
10a06: f004 fe4d bl 156a4 <__assert_fail>
10a0a: bf00 nop
10a0c: 0006e81a .word 0x0006e81a
10a10: 0006e8ee .word 0x0006e8ee