Index: src/OFBlock.m ================================================================== --- src/OFBlock.m +++ src/OFBlock.m @@ -167,12 +167,12 @@ } alloc_failed_exception; #ifndef OF_HAVE_ATOMIC_OPS # define NUM_SPINLOCKS 8 /* needs to be a power of 2 */ # define SPINLOCK_HASH(p) ((uintptr_t)p >> 4) & (NUM_SPINLOCKS - 1) -static of_spinlock_t blockSpinlocks[NUM_SPINLOCKS]; -static of_spinlock_t byrefSpinlocks[NUM_SPINLOCKS]; +static OFSpinlock blockSpinlocks[NUM_SPINLOCKS]; +static OFSpinlock byrefSpinlocks[NUM_SPINLOCKS]; #endif void * _Block_copy(const void *block_) { @@ -202,13 +202,13 @@ #ifdef OF_HAVE_ATOMIC_OPS of_atomic_int_inc(&block->flags); #else unsigned hash = SPINLOCK_HASH(block); - OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&blockSpinlocks[hash]) == 0); block->flags++; - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&blockSpinlocks[hash]) == 0); #endif } return block; } @@ -229,22 +229,22 @@ free(block); } #else unsigned hash = SPINLOCK_HASH(block); - OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&blockSpinlocks[hash]) == 0); if ((--block->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&blockSpinlocks[hash]) == 0); if (block->flags & OF_BLOCK_HAS_COPY_DISPOSE) block->descriptor->dispose_helper(block); free(block); return; } - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&blockSpinlocks[hash]) == 0); #endif } void _Block_object_assign(void *dst_, const void *src_, const int flags_) @@ -294,33 +294,33 @@ *dst = src->forwarding; } #else unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&byrefSpinlocks[hash]) == 0); if (src->forwarding == src) src->forwarding = *dst; else { src->byref_dispose(*dst); free(*dst); *dst = src->forwarding; } OF_ENSURE( - of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); + OFSpinlockUnlock(&byrefSpinlocks[hash]) == 0); #endif } else *dst = src; #ifdef OF_HAVE_ATOMIC_OPS of_atomic_int_inc(&(*dst)->flags); #else unsigned hash = SPINLOCK_HASH(*dst); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&byrefSpinlocks[hash]) == 0); (*dst)->flags++; - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&byrefSpinlocks[hash]) == 0); #endif break; } } @@ -355,21 +355,21 @@ free(object); } #else unsigned hash = SPINLOCK_HASH(object); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&byrefSpinlocks[hash]) == 0); if ((--object->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { OF_ENSURE( - of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); + OFSpinlockUnlock(&byrefSpinlocks[hash]) == 0); if (object->flags & OF_BLOCK_HAS_COPY_DISPOSE) object->byref_dispose(object); free(object); } - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&byrefSpinlocks[hash]) == 0); #endif break; } } @@ -376,12 +376,12 @@ @implementation OFBlock + (void)load { #ifndef OF_HAVE_ATOMIC_OPS for (size_t i = 0; i < NUM_SPINLOCKS; i++) - if (of_spinlock_new(&blockSpinlocks[i]) != 0 || - of_spinlock_new(&byrefSpinlocks[i]) != 0) + if (OFSpinlockNew(&blockSpinlocks[i]) != 0 || + OFSpinlockNew(&byrefSpinlocks[i]) != 0) @throw [OFInitializationFailedException exceptionWithClass: self]; #endif #ifdef OF_APPLE_RUNTIME Index: src/OFObject.m ================================================================== --- src/OFObject.m +++ src/OFObject.m @@ -80,11 +80,11 @@ #endif struct pre_ivar { int retainCount; #if !defined(OF_HAVE_ATOMIC_OPS) && !defined(OF_AMIGAOS) - of_spinlock_t retainCountSpinlock; + OFSpinlock retainCountSpinlock; #endif }; #define PRE_IVARS_ALIGN ((sizeof(struct pre_ivar) + \ (OF_BIGGEST_ALIGNMENT - 1)) & ~(OF_BIGGEST_ALIGNMENT - 1)) @@ -306,11 +306,11 @@ } ((struct pre_ivar *)instance)->retainCount = 1; #if !defined(OF_HAVE_ATOMIC_OPS) && !defined(OF_AMIGAOS) - if OF_UNLIKELY (of_spinlock_new( + if OF_UNLIKELY (OFSpinlockNew( &((struct pre_ivar *)instance)->retainCountSpinlock) != 0) { free(instance); @throw [OFInitializationFailedException exceptionWithClass: class]; } @@ -1112,13 +1112,13 @@ PRE_IVARS->retainCount++; # ifndef OF_AMIGAOS_M68K Permit(); # endif #else - OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock) == 0); + OF_ENSURE(OFSpinlockLock(&PRE_IVARS->retainCountSpinlock) == 0); PRE_IVARS->retainCount++; - OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock) == 0); + OF_ENSURE(OFSpinlockUnlock(&PRE_IVARS->retainCountSpinlock) == 0); #endif return self; } @@ -1148,13 +1148,13 @@ if (retainCount == 0) [self dealloc]; #else int retainCount; - OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock) == 0); + OF_ENSURE(OFSpinlockLock(&PRE_IVARS->retainCountSpinlock) == 0); retainCount = --PRE_IVARS->retainCount; - OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock) == 0); + OF_ENSURE(OFSpinlockUnlock(&PRE_IVARS->retainCountSpinlock) == 0); if (retainCount == 0) [self dealloc]; #endif } Index: src/mutex.h ================================================================== --- src/mutex.h +++ src/mutex.h @@ -37,16 +37,16 @@ typedef struct SignalSemaphore OFPlainMutex; #endif #if defined(OF_HAVE_ATOMIC_OPS) # import "atomic.h" -typedef volatile int of_spinlock_t; +typedef volatile int OFSpinlock; # define OF_SPINCOUNT 10 #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) -typedef pthread_spinlock_t of_spinlock_t; +typedef pthread_spinlock_t OFSpinlock; #else -typedef OFPlainMutex of_spinlock_t; +typedef OFPlainMutex OFSpinlock; #endif #ifdef OF_HAVE_SCHED_YIELD # include #endif @@ -90,11 +90,11 @@ Sleep(0); #endif } static OF_INLINE int -of_spinlock_new(of_spinlock_t *spinlock) +OFSpinlockNew(OFSpinlock *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) *spinlock = 0; return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) @@ -103,11 +103,11 @@ return OFPlainMutexNew(spinlock); #endif } static OF_INLINE int -of_spinlock_trylock(of_spinlock_t *spinlock) +OFSpinlockTryLock(OFSpinlock *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) if (of_atomic_int_cmpswap(spinlock, 0, 1)) { of_memory_barrier_acquire(); return 0; @@ -120,20 +120,20 @@ return OFPlainMutexTryLock(spinlock); #endif } static OF_INLINE int -of_spinlock_lock(of_spinlock_t *spinlock) +OFSpinlockLock(OFSpinlock *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) size_t i; for (i = 0; i < OF_SPINCOUNT; i++) - if (of_spinlock_trylock(spinlock) == 0) + if (OFSpinlockTryLock(spinlock) == 0) return 0; - while (of_spinlock_trylock(spinlock) == EBUSY) + while (OFSpinlockTryLock(spinlock) == EBUSY) OFYieldThread(); return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_lock(spinlock); @@ -141,11 +141,11 @@ return OFPlainMutexLock(spinlock); #endif } static OF_INLINE int -of_spinlock_unlock(of_spinlock_t *spinlock) +OFSpinlockUnlock(OFSpinlock *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) bool ret = of_atomic_int_cmpswap(spinlock, 1, 0); of_memory_barrier_release(); @@ -157,15 +157,15 @@ return OFPlainMutexUnlock(spinlock); #endif } static OF_INLINE int -of_spinlock_free(of_spinlock_t *spinlock) +OFSpinlockFree(OFSpinlock *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) return pthread_spin_destroy(spinlock); #else return OFPlainMutexFree(spinlock); #endif } Index: src/runtime/arc.m ================================================================== --- src/runtime/arc.m +++ src/runtime/arc.m @@ -27,11 +27,11 @@ size_t count; }; static struct objc_hashtable *hashtable; #ifdef OF_HAVE_THREADS -static of_spinlock_t spinlock; +static OFSpinlock spinlock; #endif static uint32_t hash(const void *object) { @@ -47,11 +47,11 @@ OF_CONSTRUCTOR() { hashtable = objc_hashtable_new(hash, equal, 2); #ifdef OF_HAVE_THREADS - if (of_spinlock_new(&spinlock) != 0) + if (OFSpinlockNew(&spinlock) != 0) OBJC_ERROR("Failed to create spinlock!"); #endif } id @@ -118,11 +118,11 @@ objc_storeWeak(id *object, id value) { struct weak_ref *old; #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&spinlock) != 0) + if (OFSpinlockLock(&spinlock) != 0) OBJC_ERROR("Failed to lock spinlock!"); #endif if (*object != nil && (old = objc_hashtable_get(hashtable, *object)) != NULL) { @@ -175,11 +175,11 @@ value = nil; *object = value; #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&spinlock) != 0) + if (OFSpinlockUnlock(&spinlock) != 0) OBJC_ERROR("Failed to unlock spinlock!"); #endif return value; } @@ -189,20 +189,20 @@ { id value = nil; struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&spinlock) != 0) + if (OFSpinlockLock(&spinlock) != 0) OBJC_ERROR("Failed to lock spinlock!"); #endif if (*object != nil && (ref = objc_hashtable_get(hashtable, *object)) != NULL) value = *object; #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&spinlock) != 0) + if (OFSpinlockUnlock(&spinlock) != 0) OBJC_ERROR("Failed to unlock spinlock!"); #endif if (class_respondsToSelector(object_getClass(value), @selector(retainWeakReference)) && [value retainWeakReference]) @@ -240,11 +240,11 @@ objc_moveWeak(id *dest, id *src) { struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&spinlock) != 0) + if (OFSpinlockLock(&spinlock) != 0) OBJC_ERROR("Failed to lock spinlock!"); #endif if (*src != nil && (ref = objc_hashtable_get(hashtable, *src)) != NULL) { @@ -258,11 +258,11 @@ *dest = *src; *src = nil; #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&spinlock) != 0) + if (OFSpinlockUnlock(&spinlock) != 0) OBJC_ERROR("Failed to unlock spinlock!"); #endif } void @@ -269,11 +269,11 @@ objc_zero_weak_references(id value) { struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&spinlock) != 0) + if (OFSpinlockLock(&spinlock) != 0) OBJC_ERROR("Failed to lock spinlock!"); #endif if ((ref = objc_hashtable_get(hashtable, value)) != NULL) { for (size_t i = 0; i < ref->count; i++) @@ -283,9 +283,9 @@ free(ref->locations); free(ref); } #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&spinlock) != 0) + if (OFSpinlockUnlock(&spinlock) != 0) OBJC_ERROR("Failed to unlock spinlock!"); #endif } Index: src/runtime/exception.m ================================================================== --- src/runtime/exception.m +++ src/runtime/exception.m @@ -240,15 +240,15 @@ #endif static objc_uncaught_exception_handler_t uncaughtExceptionHandler; static struct objc_exception emergencyExceptions[NUM_EMERGENCY_EXCEPTIONS]; #ifdef OF_HAVE_THREADS -static of_spinlock_t emergencyExceptionsSpinlock; +static OFSpinlock emergencyExceptionsSpinlock; OF_CONSTRUCTOR() { - if (of_spinlock_new(&emergencyExceptionsSpinlock) != 0) + if (OFSpinlockNew(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot create spinlock!"); } #endif static uint64_t @@ -709,18 +709,18 @@ static void emergencyExceptionCleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception *ex) { #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&emergencyExceptionsSpinlock) != 0) + if (OFSpinlockLock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif ex->class = 0; #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&emergencyExceptionsSpinlock) != 0) + if (OFSpinlockUnlock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot unlock spinlock!"); #endif } void @@ -729,11 +729,11 @@ struct objc_exception *e = calloc(1, sizeof(*e)); bool emergency = false; if (e == NULL) { #ifdef OF_HAVE_THREADS - if (of_spinlock_lock(&emergencyExceptionsSpinlock) != 0) + if (OFSpinlockLock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif for (uint_fast8_t i = 0; i < NUM_EMERGENCY_EXCEPTIONS; i++) { if (emergencyExceptions[i].exception.class == 0) { @@ -744,11 +744,11 @@ break; } } #ifdef OF_HAVE_THREADS - if (of_spinlock_unlock(&emergencyExceptionsSpinlock) != 0) + if (OFSpinlockUnlock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif } if (e == NULL) Index: src/runtime/property.m ================================================================== --- src/runtime/property.m +++ src/runtime/property.m @@ -22,18 +22,18 @@ #ifdef OF_HAVE_THREADS # import "mutex.h" # define NUM_SPINLOCKS 8 /* needs to be a power of 2 */ # define SPINLOCK_HASH(p) ((unsigned)((uintptr_t)p >> 4) & (NUM_SPINLOCKS - 1)) -static of_spinlock_t spinlocks[NUM_SPINLOCKS]; +static OFSpinlock spinlocks[NUM_SPINLOCKS]; #endif #ifdef OF_HAVE_THREADS OF_CONSTRUCTOR() { for (size_t i = 0; i < NUM_SPINLOCKS; i++) - if (of_spinlock_new(&spinlocks[i]) != 0) + if (OFSpinlockNew(&spinlocks[i]) != 0) OBJC_ERROR("Failed to initialize spinlocks!"); } #endif id @@ -42,15 +42,15 @@ if (atomic) { id *ptr = (id *)(void *)((char *)self + offset); #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(ptr); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&spinlocks[hash]) == 0); @try { return [[*ptr retain] autorelease]; } @finally { - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&spinlocks[hash]) == 0); } #else return [[*ptr retain] autorelease]; #endif } @@ -65,11 +65,11 @@ if (atomic) { id *ptr = (id *)(void *)((char *)self + offset); #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(ptr); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&spinlocks[hash]) == 0); @try { #endif id old = *ptr; switch (copy) { @@ -84,11 +84,11 @@ } [old release]; #ifdef OF_HAVE_THREADS } @finally { - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&spinlocks[hash]) == 0); } #endif return; } @@ -117,15 +117,15 @@ { if (atomic) { #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&spinlocks[hash]) == 0); #endif memcpy(dest, src, size); #ifdef OF_HAVE_THREADS - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&spinlocks[hash]) == 0); #endif return; } @@ -138,15 +138,15 @@ { if (atomic) { #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockLock(&spinlocks[hash]) == 0); #endif memcpy(dest, src, size); #ifdef OF_HAVE_THREADS - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); + OF_ENSURE(OFSpinlockUnlock(&spinlocks[hash]) == 0); #endif return; } Index: src/socket.m ================================================================== --- src/socket.m +++ src/socket.m @@ -135,11 +135,11 @@ # if defined(OF_HAVE_THREADS) && (!defined(OF_AMIGAOS) || defined(OF_MORPHOS)) mutex = [[OFMutex alloc] init]; atexit(releaseMutex); # ifdef OF_WII - if (of_spinlock_new(&spinlock) != 0) + if (OFSpinlockNew(&spinlock) != 0) return; # endif # endif initSuccessful = true;