mirror of
git://git.musl-libc.org/musl
synced 2025-01-09 16:19:50 +00:00
1281779330
in our memory model, all atomics are supposed to be full barriers;
stores are not release-only. this is important because store is used
as an unlock operation in places where it needs to acquire the waiter
count to determine if a futex wake is needed. at least in the
malloc-internal locks, but possibly elsewhere, soft deadlocks from
missing futex wake (breakable by poking the threads to restart the
syscall, e.g. by attaching a tracer) were reported to occur.
once the malloc lock is replaced with Jens Gustedt's new lock
implementation (see commit 47d0bcd476),
malloc will not be affected by the issue, but it's not clear that
other uses won't be. reducing the strength of the ordering properties
required from a_store would require a thorough analysis of how it's
used.
to fix the problem, I'm removing the powerpc[64]-specific a_store
definition; now, the top-level atomic.h will implement a_store using
a_barrier on both sides of the store.
it's not clear to me yet whether there might be issues with the other
atomics. it's possible that a_post_llsc needs to be replaced with a
full barrier to guarantee the formal semanics we want, but either way
I think the difference is unlikely to impact the way we use them.
63 lines
1.3 KiB
C
63 lines
1.3 KiB
C
#define a_ll a_ll
|
|
static inline int a_ll(volatile int *p)
|
|
{
|
|
int v;
|
|
__asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p));
|
|
return v;
|
|
}
|
|
|
|
#define a_sc a_sc
|
|
static inline int a_sc(volatile int *p, int v)
|
|
{
|
|
int r;
|
|
__asm__ __volatile__ (
|
|
"stwcx. %2, 0, %3 ; mfcr %0"
|
|
: "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc");
|
|
return r & 0x20000000; /* "bit 2" of "cr0" (backwards bit order) */
|
|
}
|
|
|
|
#define a_ll_p a_ll_p
|
|
static inline void *a_ll_p(volatile void *p)
|
|
{
|
|
void *v;
|
|
__asm__ __volatile__ ("ldarx %0, 0, %2" : "=r"(v) : "m"(*(void *volatile *)p), "r"(p));
|
|
return v;
|
|
}
|
|
|
|
#define a_sc_p a_sc_p
|
|
static inline int a_sc_p(volatile void *p, void *v)
|
|
{
|
|
int r;
|
|
__asm__ __volatile__ (
|
|
"stdcx. %2, 0, %3 ; mfcr %0"
|
|
: "=r"(r), "=m"(*(void *volatile *)p) : "r"(v), "r"(p) : "memory", "cc");
|
|
return r & 0x20000000; /* "bit 2" of "cr0" (backwards bit order) */
|
|
}
|
|
|
|
#define a_barrier a_barrier
|
|
static inline void a_barrier()
|
|
{
|
|
__asm__ __volatile__ ("sync" : : : "memory");
|
|
}
|
|
|
|
#define a_pre_llsc a_barrier
|
|
|
|
#define a_post_llsc a_post_llsc
|
|
static inline void a_post_llsc()
|
|
{
|
|
__asm__ __volatile__ ("isync" : : : "memory");
|
|
}
|
|
|
|
#define a_crash a_crash
|
|
static inline void a_crash()
|
|
{
|
|
__asm__ __volatile__ (".long 0");
|
|
}
|
|
|
|
#define a_clz_64 a_clz_64
|
|
static inline int a_clz_64(uint64_t x)
|
|
{
|
|
__asm__ ("cntlzd %0, %1" : "=r"(x) : "r"(x));
|
|
return x;
|
|
}
|