Commit 769f36db authored by Sebastian Wilhelmi's avatar Sebastian Wilhelmi Committed by Sebastian Wilhelmi

Moved the assembler functions from gatomic.h to gatomic.c, which makes for


2004-02-29  Sebastian Wilhelmi  <seppi@seppi.de>

	* configure.in, glib/gatomic.c, glib/gatomic.h: Moved the
	assembler functions from gatomic.h to gatomic.c, which makes for
	better maintainability. Also use gint instead of gint32 to be able
	to use reference counting for ABI-fixed structures with
	gint/guint.

	* glib/gthread.h: Adapted accordingly.

	* tests/atomic-test.c: Updated to test for G_MAXINT and G_MININT.
parent fe2efd06
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GAtomic: atomic integer operation.
* g_atomic_*: atomic operations.
* Copyright (C) 2003 Sebastian Wilhelmi
*
* This library is free software; you can redistribute it and/or
......@@ -20,67 +20,414 @@
* Boston, MA 02111-1307, USA.
*/
#include <glib.h>
#include "config.h"
#ifdef G_THREADS_ENABLED
# if !defined (G_ATOMIC_USE_FALLBACK_IMPLEMENTATION)
/* We have an inline implementation, which we can now use for the
* fallback implementation. This fallback implementation is only used by
* modules, which are not compliled with gcc
#include "glib.h"
#if defined (__GNUC__)
# if defined (G_ATOMIC_I486)
/* Adapted from CVS version 1.10 of glibc's sysdeps/i386/i486/bits/atomic.h
*/
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
gint result;
__asm__ __volatile__ ("lock; xaddl %0,%1"
: "=r" (result), "=m" (*atomic)
: "0" (val), "m" (*atomic));
return result;
}
void
g_atomic_int_add (gint *atomic,
gint val)
{
__asm__ __volatile__ ("lock; addl %1,%0"
: "=m" (*atomic)
: "ir" (val), "m" (*atomic));
}
gboolean
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
gint result;
__asm __volatile ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
/* The same code as above, as on i386 gpointer is 32 bit as well.
* Duplicating the code here seems more natural than casting the
* arguments and calling the former function */
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
__asm __volatile ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
# elif defined (G_ATOMIC_SPARCV9)
/* Adapted from CVS version 1.3 of glibc's sysdeps/sparc/sparc64/bits/atomic.h
*/
# define ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \
({ \
gint __result; \
__asm __volatile ("cas [%4], %2, %0" \
: "=r" (__result), "=m" (*(atomic)) \
: "r" (oldval), "m" (*(atomic)), "r" (atomic), \
"0" (newval)); \
__result == oldval; \
})
# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
__asm __volatile ("cas [%4], %2, %0"
: "=r" (result), "=m" (*atomic)
: "r" (oldval), "m" (*atomic), "r" (atomic),
"0" (newval));
return result == oldval;
}
# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
gpointer *a = atomic;
__asm __volatile ("casx [%4], %2, %0"
: "=r" (result), "=m" (*a)
: "r" (oldval), "m" (*a), "r" (a),
"0" (newval));
return result != 0;
}
# else /* What's that */
# error "Your system has an unsupported pointer size"
# endif /* GLIB_SIZEOF_VOID_P */
# define G_ATOMIC_MEMORY_BARRIER \
__asm __volatile ("membar #LoadLoad | #LoadStore" \
" | #StoreLoad | #StoreStore" : : : "memory")
# elif defined (G_ATOMIC_ALPHA)
/* Adapted from CVS version 1.3 of glibc's sysdeps/alpha/bits/atomic.h
*/
# define ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \
({ \
gint __result; \
gint __prev; \
__asm__ __volatile__ ( \
" mb\n" \
"1: ldl_l %0,%2\n" \
" cmpeq %0,%3,%1\n" \
" beq %1,2f\n" \
" mov %4,%1\n" \
" stl_c %1,%2\n" \
" beq %1,1b\n" \
" mb\n" \
"2:" \
: "=&r" (__prev), \
"=&r" (__result) \
: "m" (*(atomic)), \
"Ir" (oldval), \
"Ir" (newval) \
: "memory"); \
__result != 0; \
})
# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gint result;
gpointer prev;
__asm__ __volatile__ (
" mb\n"
"1: ldl_l %0,%2\n"
" cmpeq %0,%3,%1\n"
" beq %1,2f\n"
" mov %4,%1\n"
" stl_c %1,%2\n"
" beq %1,1b\n"
" mb\n"
"2:"
: "=&r" (prev),
"=&r" (result)
: "m" (*atomic),
"Ir" (oldval),
"Ir" (newval)
: "memory");
return result != 0;
}
# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gint result;
gpointer prev;
__asm__ __volatile__ (
" mb\n"
"1: ldq_l %0,%2\n"
" cmpeq %0,%3,%1\n"
" beq %1,2f\n"
" mov %4,%1\n"
" stq_c %1,%2\n"
" beq %1,1b\n"
" mb\n"
"2:"
: "=&r" (prev),
"=&r" (result)
: "m" (*atomic),
"Ir" (oldval),
"Ir" (newval)
: "memory");
return result != 0;
}
# else /* What's that */
# error "Your system has an unsupported pointer size"
# endif /* GLIB_SIZEOF_VOID_P */
# define G_ATOMIC_MEMORY_BARRIER __asm ("mb" : : : "memory")
# elif defined (G_ATOMIC_X86_64)
/* Adapted from CVS version 1.9 of glibc's sysdeps/x86_64/bits/atomic.h
*/
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
gint result;
gint32
g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
gint32 val)
__asm__ __volatile__ ("lock; xaddl %0,%1"
: "=r" (result), "=m" (*atomic)
: "0" (val), "m" (*atomic));
return result;
}
void
g_atomic_int_add (gint *atomic,
gint val)
{
return g_atomic_int_exchange_and_add (atomic, val);
__asm__ __volatile__ ("lock; addl %1,%0"
: "=m" (*atomic)
: "ir" (val), "m" (*atomic));
}
gboolean
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
gint result;
__asm __volatile ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
__asm __volatile ("lock; cmpxchgq %q2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
# elif defined (G_ATOMIC_POWERPC)
/* Adapted from CVS version 1.12 of glibc's sysdeps/powerpc/bits/atomic.h
* and CVS version 1.3 of glibc's sysdeps/powerpc/powerpc32/bits/atomic.h
* and CVS version 1.2 of glibc's sysdeps/powerpc/powerpc64/bits/atomic.h
*/
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
gint result, temp;
__asm __volatile ("1: lwarx %0,0,%3\n"
" add %1,%0,%4\n"
" stwcx. %1,0,%3\n"
" bne- 1b"
: "=&b" (result), "=&r" (temp), "=m" (*atomic)
: "b" (atomic), "r" (val), "2" (*atomic)
: "cr0", "memory");
return result;
}
/* The same as above, to save a function call repeated here */
void
g_atomic_int_add_fallback (gint32 *atomic,
gint32 val)
g_atomic_int_add (gint *atomic,
gint val)
{
g_atomic_int_add (atomic, val);
gint result, temp;
__asm __volatile ("1: lwarx %0,0,%3\n"
" add %1,%0,%4\n"
" stwcx. %1,0,%3\n"
" bne- 1b"
: "=&b" (result), "=&r" (temp), "=m" (*atomic)
: "b" (atomic), "r" (val), "2" (*atomic)
: "cr0", "memory");
}
# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
gboolean
g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
gint32 oldval,
gint32 newval)
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
return g_atomic_int_compare_and_exchange (atomic, oldval, newval);
gint result;
__asm __volatile ("sync\n"
"1: lwarx %0,0,%1\n"
" subf. %0,%2,%0\n"
" bne 2f\n"
" stwcx. %3,0,%1\n"
" bne- 1b\n"
"2: isync"
: "=&r" (result)
: "b" (atomic), "r" (oldval), "r" (newval)
: "cr0", "memory");
return result == 0;
}
gboolean
g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
gpointer oldval,
gpointer newval)
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
return g_atomic_pointer_compare_and_exchange (atomic, oldval, newval);
gpointer result;
__asm __volatile ("sync\n"
"1: lwarx %0,0,%1\n"
" subf. %0,%2,%0\n"
" bne 2f\n"
" stwcx. %3,0,%1\n"
" bne- 1b\n"
"2: isync"
: "=&r" (result)
: "b" (atomic), "r" (oldval), "r" (newval)
: "cr0", "memory");
return result == 0;
}
# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
gboolean
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
__asm __volatile ("sync\n"
"1: lwarx %0,0,%1\n"
" extsw %0,%0\n"
" subf. %0,%2,%0\n"
" bne 2f\n"
" stwcx. %3,0,%1\n"
" bne- 1b\n"
"2: isync"
: "=&r" (result)
: "b" (atomic), "r" (oldval), "r" (newval)
: "cr0", "memory");
return result == 0;
}
gint32
g_atomic_int_get_fallback (gint32 *atomic)
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
return g_atomic_int_get (atomic);
gpointer result;
__asm __volatile ("sync\n"
"1: ldarx %0,0,%1\n"
" subf. %0,%2,%0\n"
" bne 2f\n"
" stdcx. %3,0,%1\n"
" bne- 1b\n"
"2: isync"
: "=&r" (result)
: "b" (atomic), "r" (oldval), "r" (newval)
: "cr0", "memory");
return result == 0;
}
# else /* What's that */
# error "Your system has an unsupported pointer size"
# endif /* GLIB_SIZEOF_VOID_P */
# define G_ATOMIC_MEMORY_BARRIER __asm ("sync" : : : "memory")
gint32
g_atomic_pointer_get_fallback (gpointer *atomic)
# elif defined (G_ATOMIC_IA64)
/* Adapted from CVS version 1.8 of glibc's sysdeps/ia64/bits/atomic.h
*/
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
return g_atomic_int_get (atomic);
}
return __sync_fetch_and_add_si (atomic, val);
}
void
g_atomic_int_add (gint *atomic,
gint val)
{
__sync_fetch_and_add_si (atomic, val);
}
gboolean
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
return __sync_bool_compare_and_swap_si (atomic, oldval, newval);
}
gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
return __sync_bool_compare_and_swap_di ((long *)atomic,
(long)oldval, (long)newval);
}
# define G_ATOMIC_MEMORY_BARRIER __sync_synchronize ()
# else /* !G_ATOMIC */
# define DEFINE_WITH_MUTEXES
# endif /* G_ATOMIC */
#else /* !__GNUC__ */
# define DEFINE_WITH_MUTEXES
#endif /* __GNUC__ */
# else /* !G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
#ifdef DEFINE_WITH_MUTEXES
/* We have to use the slow, but safe locking method */
G_LOCK_DEFINE_STATIC (g_atomic_lock);
gint32
g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
gint32 val)
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
gint32 result;
gint result;
G_LOCK (g_atomic_lock);
result = *atomic;
......@@ -92,8 +439,8 @@ g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
void
g_atomic_int_add_fallback (gint32 *atomic,
gint32 val)
g_atomic_int_add (gint *atomic,
gint val)
{
G_LOCK (g_atomic_lock);
*atomic += val;
......@@ -101,9 +448,9 @@ g_atomic_int_add_fallback (gint32 *atomic,
}
gboolean
g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
gint32 oldval,
gint32 newval)
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
gboolean result;
......@@ -121,9 +468,9 @@ g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
}
gboolean
g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
gpointer oldval,
gpointer newval)
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gboolean result;
......@@ -140,10 +487,10 @@ g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
return result;
}
static inline gint32
g_atomic_int_get_fallback (gint32 *atomic)
gint
g_atomic_int_get (gint *atomic)
{
gint32 result;
gint result;
G_LOCK (g_atomic_lock);
result = *atomic;
......@@ -152,8 +499,8 @@ g_atomic_int_get_fallback (gint32 *atomic)
return result;
}
static inline gpointer
g_atomic_pointer_get_fallback (gpointer *atomic)
gpointer
g_atomic_pointer_get (gpointer *atomic)
{
gpointer result;
......@@ -163,16 +510,56 @@ g_atomic_pointer_get_fallback (gpointer *atomic)
return result;
}
#elif defined (G_ATOMIC_OP_MEMORY_BARRIER_NEEDED)
gint
g_atomic_int_get (gint *atomic)
{
gint result = *atomic;
G_ATOMIC_MEMORY_BARRIER;
# endif /* G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
#else /* !G_THREADS_ENABLED */
gint32 g_atomic_int_exchange_and_add (gint32 *atomic,
gint32 val)
return result;
}
gpointer
g_atomic_pointer_get (gpointer *atomic)
{
gint32 result = *atomic;
*atomic += val;
gpointer result = *atomic;
G_ATOMIC_MEMORY_BARRIER;
return result;
}
#endif /* DEFINE_WITH_MUTEXES || G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */
#ifdef ATOMIC_INT_CMP_XCHG
gboolean
g_atomic_int_compare_and_exchange (gint *atomic,
gint oldval,
gint newval)
{
return ATOMIC_INT_CMP_XCHG (atomic, oldval, newval);
}
#endif /* G_THREADS_ENABLED */
gint
g_atomic_int_exchange_and_add (gint *atomic,
gint val)
{
gint result;
do
result = *atomic;
while (!ATOMIC_INT_CMP_XCHG (atomic, result, result + val));
return result;
}
void
g_atomic_int_add (gint *atomic,
gint val)
{
gint result;
do
result = *atomic;
while (!ATOMIC_INT_CMP_XCHG (atomic, result, result + val));
}
#endif /* ATOMIC_INT_CMP_XCHG */
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GAtomic: atomic integer operation.
* g_atomic_*: atomic operations.
* Copyright (C) 2003 Sebastian Wilhelmi
*
* This library is free software; you can redistribute it and/or
......@@ -34,507 +34,24 @@
G_BEGIN_DECLS
#ifdef G_THREADS_ENABLED
gint32 g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
gint32 val);
void g_atomic_int_add_fallback (gint32 *atomic,
gint32 val);
gboolean g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
gint32 oldval,
gint32 newval);
gboolean g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
gpointer oldval,
gpointer newval);
# if defined (__GNUC__)
# if defined (G_ATOMIC_INLINED_IMPLEMENTATION_I486)
/* Adapted from CVS version 1.10 of glibc's sysdeps/i386/i486/bits/atomic.h
*/
static inline gint32
g_atomic_int_exchange_and_add (gint32 *atomic,
gint32 val)
{
gint32 result;
__asm__ __volatile__ ("lock; xaddl %0,%1"
: "=r" (result), "=m" (*atomic)
: "0" (val), "m" (*atomic));
return result;
}
static inline void
g_atomic_int_add (gint32 *atomic,
gint32 val)
{
__asm__ __volatile__ ("lock; addl %1,%0"
: "=m" (*atomic)
: "ir" (val), "m" (*atomic));
}
static inline gboolean
g_atomic_int_compare_and_exchange (gint32 *atomic,
gint32 oldval,
gint32 newval)
{
gint32 result;
__asm __volatile ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
/* The same code as above, as on i386 gpointer is 32 bit as well.
* Duplicating the code here seems more natural than casting the
* arguments and calling the former function */
static inline gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
__asm __volatile ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
# define G_ATOMIC_MEMORY_BARRIER() /* Not needed */
# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_SPARCV9) \
&& (defined(__sparcv8) || defined(__sparcv9) || defined(__sparc_v9__))
/* Adapted from CVS version 1.3 of glibc's sysdeps/sparc/sparc64/bits/atomic.h
*/
/* Why the test for __sparcv8, wheras really the sparcv9 architecture
* is required for the folowing assembler instructions? On
* sparc-solaris the only difference detectable at compile time
* between no -m and -mcpu=v9 is __sparcv8.
*
* However, in case -mcpu=v8 is set, the assembler will fail. This
* should be rare however, as there are only very few v8-not-v9
* machines still out there (and we can't do better).
*/
static inline gboolean
g_atomic_int_compare_and_exchange (gint32 *atomic,
gint32 oldval,
gint32 newval)
{
gint32 result;
__asm __volatile ("cas [%4], %2, %0"
: "=r" (result), "=m" (*atomic)
: "r" (oldval), "m" (*atomic), "r" (atomic),
"0" (newval));
return result != 0;
}
# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
static inline gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
__asm __volatile ("cas [%4], %2, %0"
: "=r" (result), "=m" (*atomic)
: "r" (oldval), "m" (*atomic), "r" (atomic),
"0" (newval));
return result != 0;
}
# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
static inline gboolean
g_atomic_pointer_compare_and_exchange (gpointer *atomic,
gpointer oldval,
gpointer newval)
{
gpointer result;
gpointer *a = atomic;
__asm __volatile ("casx [%4], %2, %0"
: "=r" (result), "=m" (*a)
: "r" (oldval), "m" (*a), "r" (a),
"0" (newval));
return result != 0;
}
# else /* What's that */
# error "Your system has an unsupported pointer size"
# endif /* GLIB_SIZEOF_VOID_P */
static inline gint32
g_atomic_int_exchange_and_add (gint32 *atomic,
gint32 val)
{
gint32 result;
do
result = *atomic;
while (!g_atomic_int_compare_and_exchange (atomic, result, result + val));
return result;
}
static inline void
g_atomic_int_add (gint32 *atomic,
gint32 val)
{
g_atomic_int_exchange_and_add (atomic, val);
}
# define G_ATOMIC_MEMORY_BARRIER() \
__asm __volatile ("membar #LoadLoad | #LoadStore" \
" | #StoreLoad | #StoreStore" : : : "memory")
# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_ALPHA)
/* Adapted from CVS version 1.3 of glibc's sysdeps/alpha/bits/atomic.h
*/
static inline gboolean
g_atomic_int_compare_and_exchange (gint32 *atomic,
gint32 oldval,
gint32 newval)
{
gint32 result;
gint32 prev;
__asm__ __volatile__ (
" mb\n"
"1: ldl_l %0,%2\n"
" cmpeq %0,%3,%1\n"
" beq %1,2f\n"
" mov %4,%1\n"
" stl_c %1,%2\n"
" beq %1,1b\n"
" mb\n"
"2:"
: "=&r" (prev),