void
-_pthread_cleanup_push (buffer, routine, arg)
- struct _pthread_cleanup_buffer *buffer;
- void (*routine) (void *);
- void *arg;
+_pthread_cleanup_push (
+ struct _pthread_cleanup_buffer *buffer,
+ void (*routine) (void *),
+ void *arg)
{
struct pthread *self = THREAD_SELF;
void
-_pthread_cleanup_pop (buffer, execute)
- struct _pthread_cleanup_buffer *buffer;
- int execute;
+_pthread_cleanup_pop (
+ struct _pthread_cleanup_buffer *buffer,
+ int execute)
{
struct pthread *self __attribute ((unused)) = THREAD_SELF;
void
-_pthread_cleanup_push_defer (buffer, routine, arg)
- struct _pthread_cleanup_buffer *buffer;
- void (*routine) (void *);
- void *arg;
+_pthread_cleanup_push_defer (
+ struct _pthread_cleanup_buffer *buffer,
+ void (*routine) (void *),
+ void *arg)
{
struct pthread *self = THREAD_SELF;
void
-_pthread_cleanup_pop_restore (buffer, execute)
- struct _pthread_cleanup_buffer *buffer;
- int execute;
+_pthread_cleanup_pop_restore (
+ struct _pthread_cleanup_buffer *buffer,
+ int execute)
{
struct pthread *self = THREAD_SELF;
/* Cancellation test. */
#define CANCELLATION_P(self) \
do { \
- int cancelhandling = THREAD_GETMEM (self, cancelhandling); \
- if (CANCEL_ENABLED_AND_CANCELED (cancelhandling)) \
+ int _cancelhandling = THREAD_GETMEM (self, cancelhandling); \
+ if (CANCEL_ENABLED_AND_CANCELED (_cancelhandling)) \
{ \
THREAD_SETMEM (self, result, PTHREAD_CANCELED); \
__do_cancel (); \
extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
extern int __pthread_mutex_lock_internal (pthread_mutex_t *__mutex)
attribute_hidden;
-extern int __pthread_mutex_cond_lock (pthread_mutex_t *__mutex)
- attribute_hidden internal_function;
+extern int __pthread_mutex_cond_lock (pthread_mutex_t *__mutex);
extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
extern int __pthread_mutex_unlock_internal (pthread_mutex_t *__mutex)
attribute_hidden;
/* Hide the symbol so that no definition but the one locally in the
executable or DSO is used. */
int
-__pthread_atfork (prepare, parent, child)
- void (*prepare) (void);
- void (*parent) (void);
- void (*child) (void);
+__pthread_atfork (
+ void (*prepare) (void),
+ void (*parent) (void),
+ void (*child) (void))
{
return __register_atfork (prepare, parent, child,
&__dso_handle == NULL ? NULL : __dso_handle);
#include "pthreadP.h"
int
-__pthread_attr_destroy (attr)
- pthread_attr_t *attr;
+__pthread_attr_destroy (pthread_attr_t *attr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getdetachstate (attr, detachstate)
- const pthread_attr_t *attr;
- int *detachstate;
+__pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate)
{
struct pthread_attr *iattr;
int
-pthread_attr_getguardsize (attr, guardsize)
- const pthread_attr_t *attr;
- size_t *guardsize;
+pthread_attr_getguardsize (const pthread_attr_t *attr, size_t *guardsize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getinheritsched (attr, inherit)
- const pthread_attr_t *attr;
- int *inherit;
+__pthread_attr_getinheritsched (
+ const pthread_attr_t *attr,
+ int *inherit)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getschedparam (attr, param)
- const pthread_attr_t *attr;
- struct sched_param *param;
+__pthread_attr_getschedparam (
+ const pthread_attr_t *attr,
+ struct sched_param *param)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getschedpolicy (attr, policy)
- const pthread_attr_t *attr;
- int *policy;
+__pthread_attr_getschedpolicy (
+ const pthread_attr_t *attr,
+ int *policy)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getscope (attr, scope)
- const pthread_attr_t *attr;
- int *scope;
+__pthread_attr_getscope (
+ const pthread_attr_t *attr,
+ int *scope)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstack (attr, stackaddr, stacksize)
- const pthread_attr_t *attr;
- void **stackaddr;
- size_t *stacksize;
+__pthread_attr_getstack (
+ const pthread_attr_t *attr,
+ void **stackaddr,
+ size_t *stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstackaddr (attr, stackaddr)
- const pthread_attr_t *attr;
- void **stackaddr;
+__pthread_attr_getstackaddr (
+ const pthread_attr_t *attr,
+ void **stackaddr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstacksize (attr, stacksize)
- const pthread_attr_t *attr;
- size_t *stacksize;
+__pthread_attr_getstacksize (
+ const pthread_attr_t *attr,
+ size_t *stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_init_2_1 (attr)
- pthread_attr_t *attr;
+__pthread_attr_init_2_1 (pthread_attr_t *attr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setdetachstate (attr, detachstate)
- pthread_attr_t *attr;
- int detachstate;
+__pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate)
{
struct pthread_attr *iattr;
int
-pthread_attr_setguardsize (attr, guardsize)
- pthread_attr_t *attr;
- size_t guardsize;
+pthread_attr_setguardsize (pthread_attr_t* attr, size_t guardsize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setinheritsched (attr, inherit)
- pthread_attr_t *attr;
- int inherit;
+__pthread_attr_setinheritsched (
+ pthread_attr_t *attr,
+ int inherit)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setschedparam (attr, param)
- pthread_attr_t *attr;
- const struct sched_param *param;
+__pthread_attr_setschedparam (
+ pthread_attr_t *attr,
+ const struct sched_param *param)
{
assert (sizeof (*attr) >= sizeof (struct pthread_attr));
struct pthread_attr *iattr = (struct pthread_attr *) attr;
int
-__pthread_attr_setschedpolicy (attr, policy)
- pthread_attr_t *attr;
- int policy;
+__pthread_attr_setschedpolicy (
+ pthread_attr_t *attr,
+ int policy)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setscope (attr, scope)
- pthread_attr_t *attr;
- int scope;
+__pthread_attr_setscope (
+ pthread_attr_t *attr,
+ int scope)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstack (attr, stackaddr, stacksize)
- pthread_attr_t *attr;
- void *stackaddr;
- size_t stacksize;
+__pthread_attr_setstack (
+ pthread_attr_t *attr,
+ void *stackaddr,
+ size_t stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstackaddr (attr, stackaddr)
- pthread_attr_t *attr;
- void *stackaddr;
+__pthread_attr_setstackaddr (
+ pthread_attr_t *attr,
+ void *stackaddr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstacksize (attr, stacksize)
- pthread_attr_t *attr;
- size_t stacksize;
+__pthread_attr_setstacksize (
+ pthread_attr_t *attr,
+ size_t stacksize)
{
struct pthread_attr *iattr;
int
-pthread_barrier_destroy (barrier)
- pthread_barrier_t *barrier;
+pthread_barrier_destroy (pthread_barrier_t *barrier)
{
struct pthread_barrier *ibarrier;
int result = EBUSY;
int
-pthread_barrier_init (barrier, attr, count)
- pthread_barrier_t *barrier;
- const pthread_barrierattr_t *attr;
- unsigned int count;
+pthread_barrier_init (
+ pthread_barrier_t *barrier,
+ const pthread_barrierattr_t *attr,
+ unsigned int count)
{
struct pthread_barrier *ibarrier;
int
-pthread_barrierattr_destroy (attr)
- pthread_barrierattr_t *attr;
+pthread_barrierattr_destroy (pthread_barrierattr_t *attr)
{
/* Nothing to do. */
int
-pthread_barrierattr_getpshared (attr, pshared)
- const pthread_barrierattr_t *attr;
- int *pshared;
+pthread_barrierattr_getpshared (
+ const pthread_barrierattr_t *attr,
+ int *pshared)
{
*pshared = ((const struct pthread_barrierattr *) attr)->pshared;
int
-pthread_barrierattr_init (attr)
- pthread_barrierattr_t *attr;
+pthread_barrierattr_init (pthread_barrierattr_t *attr)
{
((struct pthread_barrierattr *) attr)->pshared = PTHREAD_PROCESS_PRIVATE;
int
-pthread_barrierattr_setpshared (attr, pshared)
- pthread_barrierattr_t *attr;
- int pshared;
+pthread_barrierattr_setpshared (
+ pthread_barrierattr_t *attr,
+ int pshared)
{
struct pthread_barrierattr *iattr;
int
-pthread_cancel (th)
- pthread_t th;
+pthread_cancel (pthread_t th)
{
volatile struct pthread *pd = (volatile struct pthread *) th;
int
-__pthread_cond_destroy (cond)
- pthread_cond_t *cond;
+__pthread_cond_destroy (pthread_cond_t *cond)
{
/* Make sure we are alone. */
lll_mutex_lock (cond->__data.__lock);
int
-__pthread_cond_init (cond, cond_attr)
- pthread_cond_t *cond;
- const pthread_condattr_t *cond_attr;
+__pthread_cond_init (
+ pthread_cond_t *cond,
+ const pthread_condattr_t *cond_attr)
{
struct pthread_condattr *icond_attr = (struct pthread_condattr *) cond_attr;
int
-__pthread_condattr_destroy (attr)
- pthread_condattr_t *attr;
+__pthread_condattr_destroy (pthread_condattr_t *attr)
{
/* Nothing to be done. */
return 0;
int
-pthread_condattr_getclock (attr, clock_id)
- const pthread_condattr_t *attr;
- clockid_t *clock_id;
+pthread_condattr_getclock (
+ const pthread_condattr_t *attr,
+ clockid_t *clock_id)
{
*clock_id = (((((const struct pthread_condattr *) attr)->value) >> 1)
& ((1 << COND_CLOCK_BITS) - 1));
int
-pthread_condattr_getpshared (attr, pshared)
- const pthread_condattr_t *attr;
- int *pshared;
+pthread_condattr_getpshared (
+ const pthread_condattr_t *attr,
+ int *pshared)
{
*pshared = ((const struct pthread_condattr *) attr)->value & 1;
int
-__pthread_condattr_init (attr)
- pthread_condattr_t *attr;
+__pthread_condattr_init (pthread_condattr_t *attr)
{
memset (attr, '\0', sizeof (*attr));
int
-pthread_condattr_setclock (attr, clock_id)
- pthread_condattr_t *attr;
- clockid_t clock_id;
+pthread_condattr_setclock (
+ pthread_condattr_t *attr,
+ clockid_t clock_id)
{
/* Only a few clocks are allowed. CLOCK_REALTIME is always allowed.
CLOCK_MONOTONIC only if the kernel has the necessary support. */
#include <pthreadP.h>
int
-pthread_condattr_setpshared (attr, pshared)
- pthread_condattr_t *attr;
- int pshared;
+pthread_condattr_setpshared (
+ pthread_condattr_t *attr,
+ int pshared)
{
if (pshared != PTHREAD_PROCESS_PRIVATE
&& __builtin_expect (pshared != PTHREAD_PROCESS_SHARED, 0))
int
-pthread_detach (th)
- pthread_t th;
+pthread_detach (pthread_t th)
{
struct pthread *pd = (struct pthread *) th;
int
-__pthread_equal (thread1, thread2)
- pthread_t thread1;
- pthread_t thread2;
+__pthread_equal (pthread_t thread1, pthread_t thread2)
{
return thread1 == thread2;
}
void
-__pthread_exit (value)
- void *value;
+__pthread_exit (void* value)
{
THREAD_SETMEM (THREAD_SELF, result, value);
int
-pthread_getattr_np (thread_id, attr)
- pthread_t thread_id;
- pthread_attr_t *attr;
+pthread_getattr_np (
+ pthread_t thread_id,
+ pthread_attr_t *attr)
{
struct pthread *thread = (struct pthread *) thread_id;
struct pthread_attr *iattr = (struct pthread_attr *) attr;
int
-__pthread_getschedparam (threadid, policy, param)
- pthread_t threadid;
- int *policy;
- struct sched_param *param;
+__pthread_getschedparam (
+ pthread_t threadid,
+ int *policy,
+ struct sched_param *param)
{
struct pthread *pd = (struct pthread *) threadid;
void *
-__pthread_getspecific (key)
- pthread_key_t key;
+__pthread_getspecific (pthread_key_t key)
{
struct pthread_key_data *data;
int
-pthread_join (threadid, thread_return)
- pthread_t threadid;
- void **thread_return;
+pthread_join (pthread_t threadid, void **thread_return)
{
struct pthread *self;
struct pthread *pd = (struct pthread *) threadid;
lll_lock_t __pthread_keys_lock = LLL_LOCK_INITIALIZER;
int
-__pthread_key_create (key, destr)
- pthread_key_t *key;
- void (*destr) (void *);
+__pthread_key_create (
+ pthread_key_t *key,
+ void (*destr) (void *))
{
int result = EAGAIN;
size_t cnt;
int
-pthread_key_delete (key)
- pthread_key_t key;
+pthread_key_delete (pthread_key_t key)
{
int result = EINVAL;
int
-__pthread_mutex_destroy (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_destroy (pthread_mutex_t *mutex)
{
if (mutex->__data.__nusers != 0)
return EBUSY;
int
-__pthread_mutex_init (mutex, mutexattr)
- pthread_mutex_t *mutex;
- const pthread_mutexattr_t *mutexattr;
+__pthread_mutex_init (
+ pthread_mutex_t *mutex,
+ const pthread_mutexattr_t *mutexattr)
{
const struct pthread_mutexattr *imutexattr;
int
-__pthread_mutex_lock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_lock (pthread_mutex_t *mutex)
{
assert (sizeof (mutex->__size) >= sizeof (mutex->__data));
int
-pthread_mutex_timedlock (mutex, abstime)
- pthread_mutex_t *mutex;
- const struct timespec *abstime;
+pthread_mutex_timedlock (
+ pthread_mutex_t *mutex,
+ const struct timespec *abstime)
{
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
int result = 0;
int
-__pthread_mutex_trylock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_trylock (pthread_mutex_t *mutex)
{
pid_t id;
int
internal_function attribute_hidden
-__pthread_mutex_unlock_usercnt (mutex, decr)
- pthread_mutex_t *mutex;
- int decr;
+__pthread_mutex_unlock_usercnt (
+ pthread_mutex_t *mutex,
+ int decr)
{
switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
{
int
-__pthread_mutex_unlock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_unlock (pthread_mutex_t *mutex)
{
return __pthread_mutex_unlock_usercnt (mutex, 1);
}
int
-__pthread_mutexattr_destroy (attr)
- pthread_mutexattr_t *attr;
+__pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
{
return 0;
}
int
-pthread_mutexattr_getpshared (attr, pshared)
- const pthread_mutexattr_t *attr;
- int *pshared;
+pthread_mutexattr_getpshared (
+ const pthread_mutexattr_t *attr,
+ int *pshared)
{
const struct pthread_mutexattr *iattr;
int
-pthread_mutexattr_gettype (attr, kind)
- const pthread_mutexattr_t *attr;
- int *kind;
+pthread_mutexattr_gettype (
+ const pthread_mutexattr_t *attr,
+ int *kind)
{
const struct pthread_mutexattr *iattr;
int
-__pthread_mutexattr_init (attr)
- pthread_mutexattr_t *attr;
+__pthread_mutexattr_init (pthread_mutexattr_t *attr)
{
if (sizeof (struct pthread_mutexattr) != sizeof (pthread_mutexattr_t))
memset (attr, '\0', sizeof (*attr));
int
-pthread_mutexattr_setpshared (attr, pshared)
- pthread_mutexattr_t *attr;
- int pshared;
+pthread_mutexattr_setpshared (
+ pthread_mutexattr_t *attr,
+ int pshared)
{
struct pthread_mutexattr *iattr;
int
-__pthread_mutexattr_settype (attr, kind)
- pthread_mutexattr_t *attr;
- int kind;
+__pthread_mutexattr_settype (
+ pthread_mutexattr_t *attr,
+ int kind)
{
struct pthread_mutexattr *iattr;
int
-__pthread_rwlock_destroy (rwlock)
- pthread_rwlock_t *rwlock;
+__pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
{
/* Nothing to be done. For now. */
return 0;
int
-__pthread_rwlock_init (rwlock, attr)
- pthread_rwlock_t *rwlock;
- const pthread_rwlockattr_t *attr;
+__pthread_rwlock_init (
+ pthread_rwlock_t *rwlock,
+ const pthread_rwlockattr_t *attr)
{
const struct pthread_rwlockattr *iattr;
int
-__pthread_rwlock_tryrdlock (rwlock)
- pthread_rwlock_t *rwlock;
+__pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
{
int result = EBUSY;
int
-__pthread_rwlock_trywrlock (rwlock)
- pthread_rwlock_t *rwlock;
+__pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
{
int result = EBUSY;
int
-pthread_rwlockattr_destroy (attr)
- pthread_rwlockattr_t *attr;
+pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
{
/* Nothing to do. For now. */
int
-pthread_rwlockattr_getkind_np (attr, pref)
- const pthread_rwlockattr_t *attr;
- int *pref;
+pthread_rwlockattr_getkind_np (
+ const pthread_rwlockattr_t *attr,
+ int *pref)
{
*pref = ((const struct pthread_rwlockattr *) attr)->lockkind;
int
-pthread_rwlockattr_getpshared (attr, pshared)
- const pthread_rwlockattr_t *attr;
- int *pshared;
+pthread_rwlockattr_getpshared (
+ const pthread_rwlockattr_t *attr,
+ int *pshared)
{
*pshared = ((const struct pthread_rwlockattr *) attr)->pshared;
int
-pthread_rwlockattr_init (attr)
- pthread_rwlockattr_t *attr;
+pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
{
struct pthread_rwlockattr *iattr;
int
-pthread_rwlockattr_setkind_np (attr, pref)
- pthread_rwlockattr_t *attr;
- int pref;
+pthread_rwlockattr_setkind_np (
+ pthread_rwlockattr_t *attr,
+ int pref)
{
struct pthread_rwlockattr *iattr;
int
-pthread_rwlockattr_setpshared (attr, pshared)
- pthread_rwlockattr_t *attr;
- int pshared;
+pthread_rwlockattr_setpshared (
+ pthread_rwlockattr_t *attr,
+ int pshared)
{
struct pthread_rwlockattr *iattr;
int
-__pthread_setcancelstate (state, oldstate)
- int state;
- int *oldstate;
+__pthread_setcancelstate (
+ int state,
+ int *oldstate)
{
volatile struct pthread *self;
int
-__pthread_setcanceltype (type, oldtype)
- int type;
- int *oldtype;
+__pthread_setcanceltype (
+ int type,
+ int *oldtype)
{
volatile struct pthread *self;
int
-pthread_setconcurrency (level)
- int level;
+pthread_setconcurrency (int level)
{
if (level < 0)
return EINVAL;
int
-__pthread_setschedparam (threadid, policy, param)
- pthread_t threadid;
- int policy;
- const struct sched_param *param;
+__pthread_setschedparam (
+ pthread_t threadid,
+ int policy,
+ const struct sched_param *param)
{
struct pthread *pd = (struct pthread *) threadid;
int
-pthread_setschedprio (threadid, prio)
- pthread_t threadid;
- int prio;
+pthread_setschedprio (pthread_t threadid, int prio)
{
struct pthread *pd = (struct pthread *) threadid;
int
-__pthread_setspecific (key, value)
- pthread_key_t key;
- const void *value;
+__pthread_setspecific (
+ pthread_key_t key,
+ const void *value)
{
struct pthread *self;
unsigned int idx1st;
int
-pthread_timedjoin_np (threadid, thread_return, abstime)
- pthread_t threadid;
- void **thread_return;
- const struct timespec *abstime;
+pthread_timedjoin_np (
+ pthread_t threadid,
+ void **thread_return,
+ const struct timespec *abstime)
{
struct pthread *self;
struct pthread *pd = (struct pthread *) threadid;
int
-pthread_tryjoin_np (threadid, thread_return)
- pthread_t threadid;
- void **thread_return;
+pthread_tryjoin_np (pthread_t threadid, void **thread_return)
{
struct pthread *self;
struct pthread *pd = (struct pthread *) threadid;
int
-sem_close (sem)
- sem_t *sem;
+sem_close (sem_t *sem)
{
int result = 0;
int
-__new_sem_destroy (sem)
- sem_t *sem;
+__new_sem_destroy (sem_t *sem)
{
/* XXX Check for valid parameter. */
int
-__new_sem_getvalue (sem, sval)
- sem_t *sem;
- int *sval;
+__new_sem_getvalue (
+ sem_t *sem,
+ int *sval)
{
struct sem *isem = (struct sem *) sem;
int
-__new_sem_init (sem, pshared, value)
- sem_t *sem;
- int pshared;
- unsigned int value;
+__new_sem_init (
+ sem_t *sem,
+ int pshared,
+ unsigned int value)
{
/* Parameter sanity check. */
if (__builtin_expect (value > SEM_VALUE_MAX, 0))
int
-sem_unlink (name)
- const char *name;
+sem_unlink (const char *name)
{
char *fname;
size_t namelen;
((uintptr_t) (_address) - (_adj) < (uintptr_t) (_jmpbuf)[JB_SP] - (_adj))
/* We use the normal lobngjmp for unwinding. */
+extern __typeof(longjmp) __libc_longjmp attribute_noreturn;
#define __libc_unwind_longjmp(buf, val) __libc_longjmp (buf, val)
int
-pthread_spin_lock (lock)
- pthread_spinlock_t *lock;
+pthread_spin_lock (pthread_spinlock_t *lock)
{
__asm__ ("\n"
"1:\t" LOCK_PREFIX "decl %0\n\t"
};
int
-__pthread_cond_timedwait (cond, mutex, abstime)
- pthread_cond_t *cond;
- pthread_mutex_t *mutex;
- const struct timespec *abstime;
+__pthread_cond_timedwait (
+ pthread_cond_t *cond,
+ pthread_mutex_t *mutex,
+ const struct timespec *abstime)
{
struct _pthread_cleanup_buffer buffer;
struct _condvar_cleanup_buffer cbuffer;
int
-__pthread_cond_wait (cond, mutex)
- pthread_cond_t *cond;
- pthread_mutex_t *mutex;
+__pthread_cond_wait (
+ pthread_cond_t *cond,
+ pthread_mutex_t *mutex)
{
struct _pthread_cleanup_buffer buffer;
struct _condvar_cleanup_buffer cbuffer;
int
-pthread_sigmask (how, newmask, oldmask)
- int how;
- const sigset_t *newmask;
- sigset_t *oldmask;
+pthread_sigmask (
+ int how,
+ const sigset_t *newmask,
+ sigset_t *oldmask)
{
sigset_t local_newmask;
int
-pthread_spin_destroy (lock)
- pthread_spinlock_t *lock;
+pthread_spin_destroy (pthread_spinlock_t *lock)
{
/* Nothing to do. */
return 0;
#define _JMPBUF_UNWINDS_ADJ(_jmpbuf, _address, _adj) \
((uintptr_t) (_address) - (_adj) < (uintptr_t) (_jmpbuf)[JB_SP] - (_adj))
-/* We use the normal lobngjmp for unwinding. */
+/* We use the normal longjmp for unwinding. */
extern __typeof(longjmp) __libc_longjmp attribute_noreturn;
#define __libc_unwind_longjmp(buf, val) __libc_longjmp (buf, val)
#define lll_mutex_timedlock(futex, timeout) \
- ({ int result, ignore1, ignore2; \
+ ({ int _result, ignore1, ignore2; \
__asm__ __volatile (LOCK_INSTR "cmpxchgl %1, %3\n\t" \
"jnz _L_mutex_timedlock_%=\n\t" \
".subsection 1\n\t" \
".size _L_mutex_timedlock_%=,.-_L_mutex_timedlock_%=\n"\
".previous\n" \
"1:" \
- : "=a" (result), "=c" (ignore1), "=&d" (ignore2), \
+ : "=a" (_result), "=c" (ignore1), "=&d" (ignore2), \
"=m" (futex) \
: "0" (0), "1" (1), "m" (futex), "m" (timeout) \
: "memory"); \
- result; })
+ _result; })
#define lll_mutex_unlock(futex) \
int
-__pthread_kill (threadid, signo)
- pthread_t threadid;
- int signo;
+__pthread_kill (
+ pthread_t threadid,
+ int signo)
{
struct pthread *pd = (struct pthread *) threadid;
int
-timer_create (clock_id, evp, timerid)
- clockid_t clock_id;
- struct sigevent *evp;
- timer_t *timerid;
+timer_create (
+ clockid_t clock_id,
+ struct sigevent *evp,
+ timer_t *timerid)
{
# undef timer_create
# ifndef __ASSUME_POSIX_TIMERS
int
-timer_delete (timerid)
- timer_t timerid;
+timer_delete (timer_t timerid)
{
# undef timer_delete
# ifndef __ASSUME_POSIX_TIMERS
int
-timer_getoverrun (timerid)
- timer_t timerid;
+timer_getoverrun (timer_t timerid)
{
# undef timer_getoverrun
# ifndef __ASSUME_POSIX_TIMERS
int
-timer_gettime (timerid, value)
- timer_t timerid;
- struct itimerspec *value;
+timer_gettime (
+ timer_t timerid,
+ struct itimerspec *value)
{
# undef timer_gettime
# ifndef __ASSUME_POSIX_TIMERS
int
-timer_settime (timerid, flags, value, ovalue)
- timer_t timerid;
- int flags;
- const struct itimerspec *value;
- struct itimerspec *ovalue;
+timer_settime (
+ timer_t timerid,
+ int flags,
+ const struct itimerspec *value,
+ struct itimerspec *ovalue)
{
# undef timer_settime
# ifndef __ASSUME_POSIX_TIMERS
#define lll_mutex_timedlock(futex, timeout) \
- ({ int result, ignore1, ignore2, ignore3; \
+ ({ int _result, ignore1, ignore2, ignore3; \
__asm __volatile (LOCK_INSTR "cmpxchgl %2, %4\n\t" \
"jnz 1f\n\t" \
".subsection 1\n" \
"jmp 2f\n\t" \
".previous\n" \
"2:" \
- : "=a" (result), "=&D" (ignore1), "=S" (ignore2), \
+ : "=a" (_result), "=&D" (ignore1), "=S" (ignore2), \
"=&d" (ignore3), "=m" (futex) \
: "0" (0), "2" (1), "m" (futex), "m" (timeout) \
: "memory", "cx", "cc", "r10", "r11"); \
- result; })
+ _result; })
#define lll_mutex_unlock(futex) \
OSDN Git Service
