enable_fast_install
with_gnu_ld
enable_libtool_lock
+enable_tls
enable_sjlj_exceptions
'
ac_precious_vars='build_alias
--enable-fast-install[=PKGS]
optimize for fast installation [default=yes]
--disable-libtool-lock avoid locking (might break parallel builds)
+ --enable-tls Use thread-local storage [default=yes]
--enable-sjlj-exceptions
force use of builtin_setjmp for exceptions
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
-#line 10569 "configure"
+#line 10571 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
-#line 10675 "configure"
+#line 10677 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
fi
+# Check if we have thread-local storage
+
+
+ # Check whether --enable-tls was given.
+if test "${enable_tls+set}" = set; then :
+ enableval=$enable_tls;
+ case "$enableval" in
+ yes|no) ;;
+ *) as_fn_error "Argument to enable/disable tls must be yes or no" "$LINENO" 5 ;;
+ esac
+
+else
+ enable_tls=yes
+fi
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the target supports thread-local storage" >&5
+$as_echo_n "checking whether the target supports thread-local storage... " >&6; }
+if test "${gcc_cv_have_tls+set}" = set; then :
+ $as_echo_n "(cached) " >&6
+else
+
+ if test "$cross_compiling" = yes; then :
+ if test x$gcc_no_link = xyes; then
+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5
+fi
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+__thread int a; int b; int main() { return a = b; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ chktls_save_LDFLAGS="$LDFLAGS"
+ case $host in
+ *-*-linux*)
+ LDFLAGS="-shared -Wl,--no-undefined $LDFLAGS"
+ ;;
+ esac
+ chktls_save_CFLAGS="$CFLAGS"
+ CFLAGS="-fPIC $CFLAGS"
+ if test x$gcc_no_link = xyes; then
+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5
+fi
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+int f() { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ if test x$gcc_no_link = xyes; then
+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5
+fi
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+__thread int a; int b; int f() { return a = b; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ gcc_cv_have_tls=yes
+else
+ gcc_cv_have_tls=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+else
+ gcc_cv_have_tls=yes
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ CFLAGS="$chktls_save_CFLAGS"
+ LDFLAGS="$chktls_save_LDFLAGS"
+else
+ gcc_cv_have_tls=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+
+
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+__thread int a; int b; int main() { return a = b; }
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+ chktls_save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="-static $LDFLAGS"
+ if test x$gcc_no_link = xyes; then
+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5
+fi
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+int main() { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ if test "$cross_compiling" = yes; then :
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "cannot run test program while cross compiling
+See \`config.log' for more details." "$LINENO" 5; }
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+__thread int a; int b; int main() { return a = b; }
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+ gcc_cv_have_tls=yes
+else
+ gcc_cv_have_tls=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+ conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+else
+ gcc_cv_have_tls=yes
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS="$chktls_save_LDFLAGS"
+ if test $gcc_cv_have_tls = yes; then
+ chktls_save_CFLAGS="$CFLAGS"
+ thread_CFLAGS=failed
+ for flag in '' '-pthread' '-lpthread'; do
+ CFLAGS="$flag $chktls_save_CFLAGS"
+ if test x$gcc_no_link = xyes; then
+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5
+fi
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <pthread.h>
+ void *g(void *d) { return NULL; }
+int
+main ()
+{
+pthread_t t; pthread_create(&t,NULL,g,NULL);
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ thread_CFLAGS="$flag"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ if test "X$thread_CFLAGS" != Xfailed; then
+ break
+ fi
+ done
+ CFLAGS="$chktls_save_CFLAGS"
+ if test "X$thread_CFLAGS" != Xfailed; then
+ CFLAGS="$thread_CFLAGS $chktls_save_CFLAGS"
+ if test "$cross_compiling" = yes; then :
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "cannot run test program while cross compiling
+See \`config.log' for more details." "$LINENO" 5; }
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <pthread.h>
+ __thread int a;
+ static int *volatile a_in_other_thread;
+ static void *
+ thread_func (void *arg)
+ {
+ a_in_other_thread = &a;
+ return (void *)0;
+ }
+int
+main ()
+{
+pthread_t thread;
+ void *thread_retval;
+ int *volatile a_in_main_thread;
+ a_in_main_thread = &a;
+ if (pthread_create (&thread, (pthread_attr_t *)0,
+ thread_func, (void *)0))
+ return 0;
+ if (pthread_join (thread, &thread_retval))
+ return 0;
+ return (a_in_other_thread == a_in_main_thread);
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+ gcc_cv_have_tls=yes
+else
+ gcc_cv_have_tls=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+ conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+ CFLAGS="$chktls_save_CFLAGS"
+ fi
+ fi
+else
+ gcc_cv_have_tls=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+ conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_have_tls" >&5
+$as_echo "$gcc_cv_have_tls" >&6; }
+ if test "$enable_tls $gcc_cv_have_tls" = "yes yes"; then
+
+$as_echo "#define HAVE_TLS 1" >>confdefs.h
+
+ fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for exception model to use" >&5
$as_echo_n "checking for exception model to use... " >&6; }
enableval=$enable_sjlj_exceptions; :
else
cat > conftest.$ac_ext << EOF
-#line 11249 "configure"
+#line 11460 "configure"
@interface Frob
@end
@implementation Frob
--- /dev/null
+/* GNU Objective C Runtime @synchronized implementation
+ Copyright (C) 2010 Free Software Foundation, Inc.
+ Contributed by Nicola Pero <nicola.pero@meta-innovation.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3, or (at your option) any later version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+/*
+ This file implements objc_sync_enter() and objc_sync_exit(), the
+ two functions required to support @synchronized().
+
+ objc_sync_enter(object) needs to get a recursive lock associated
+ with 'object', and lock it.
+
+ objc_sync_exit(object) needs to get the recursive lock associated
+ with 'object', and unlock it.
+ */
+
+/* To avoid the overhead of continuously allocating and deallocating
+ locks, we implement a pool of locks. When a lock is needed for an
+ object, we get a lock from the pool and associate it with the
+ object.
+
+ The lock pool need to be protected by its own lock (the
+ "protection" lock), which has to be locked then unlocked each time
+ objc_sync_enter() and objc_sync_exit() are called. To reduce the
+ contention on the protection lock, instead of a single pool with a
+ single (global) protection lock we use a number of smaller pools,
+ each with its own pool protection lock. To decide which lock pool
+ to use for each object, we compute a hash from the object pointer.
+
+ The implementation of each lock pool uses a linked list of all the
+ locks in the pool (both unlocked, and locked); this works in the
+ assumption that the number of locks concurrently required is very
+ low. In practice, it seems that you rarely see more than a few
+ locks ever concurrently required.
+
+ A standard case is a thread acquiring a lock recursively, over and
+ over again: for example when most methods of a class are protected
+ by @synchronized(self) but they also call each other. We use
+ thread-local storage to implement a cache and optimize this case.
+ The cache stores locks that the thread successfully acquired,
+ allowing objc_sync_enter() and objc_sync_exit() to locate a lock
+ which is already held by the current thread without having to use
+ any protection lock or synchronization mechanism. It can so detect
+ recursive locks/unlocks, and transform them into no-ops that
+ require no actual locking or synchronization mechanisms at all.
+*/
+
+/* You can disable the thread-local cache (most likely to benchmark
+ the code with and without it) by compiling with
+ -DSYNC_CACHE_DISABLE, or commenting out the following line.
+ */
+/* #define SYNC_CACHE_DISABLE */
+
+/* If thread-local storage is not available, automatically disable the
+ cache.
+*/
+#ifndef HAVE_TLS
+# define SYNC_CACHE_DISABLE
+#endif
+
+#include "objc/objc-sync.h" /* For objc_sync_enter(), objc_sync_exit() */
+#include "objc/objc-api.h" /* For objc_malloc() */
+#include "objc/thr.h" /* For objc_mutex_loc() and similar */
+#include "objc-private/objc-sync.h" /* For __objc_sync_init() */
+
+/* We have 32 pools of locks, each of them protected by its own
+ protection lock. It's tempting to increase this number to reduce
+ contention; but in our tests it is high enough.
+ */
+#define SYNC_NUMBER_OF_POOLS 32
+
+/* Given an object, it determines which pool contains the associated
+ lock.
+ */
+#define SYNC_OBJECT_HASH(OBJECT) ((((size_t)OBJECT >> 8) ^ (size_t)OBJECT) & (SYNC_NUMBER_OF_POOLS - 1))
+
+/* The locks protecting each pool. */
+static objc_mutex_t sync_pool_protection_locks[SYNC_NUMBER_OF_POOLS];
+
+/* The data structure (linked list) holding the locks. */
+typedef struct lock_node
+{
+ /* Pointer to next entry on the list. NULL indicates end of list.
+ You need to hold the appropriate sync_pool_protection_locks[N] to
+ read or write this variable. */
+ struct lock_node *next;
+
+ /* The (recursive) lock. Allocated when the node is created, and
+ always not-NULL, and unchangeable, after that. */
+ objc_mutex_t lock;
+
+ /* This is how many times the objc_mutex_lock() has been called on
+ the lock (it is 0 when the lock is unused). Used to track when
+ the lock is no longer associated with an object and can be reused
+ for another object. It records "real" locks, potentially (but
+ not necessarily) by multiple threads. You need to hold the
+ appropriate sync_pool_protection_locks[N] to read or write this
+ variable. */
+ unsigned int usage_count;
+
+ /* The object that the lock is associated with. This variable can
+ only be written when holding the sync_pool_protection_locks[N]
+ and when node->usage_count == 0, ie, the lock is not being used.
+ You can read this variable either when you hold the
+ sync_pool_protection_locks[N] or when you hold node->lock,
+ because in that case you know that node->usage_count can't get to
+ zero until you release the lock. It is valid to have usage_count
+ == 0 and object != nil; in that case, the lock is not currently
+ being used, but is still currently associated with the object.
+ */
+ id object;
+
+ /* This is a counter reserved for use by the thread currently
+ holding the lock. So, you need to hold node->lock to read or
+ write this variable. It is normally 0, and if the cache is not
+ being used, it is kept at 0 (even if recursive locks are being
+ done; in that case, no difference is made between recursive and
+ non-recursive locks: they all increase usage_count, and call
+ objc_mutex_lock()). When the cache is being used, a thread may
+ be able to find a lock that it already holds using the cache; in
+ that case, to perform additional locks/unlocks it can
+ increase/decrease the recursive_usage_count (which does not
+ require any synchronization with other threads, since it's
+ protected by the node->lock itself) instead of the usage_count
+ (which requires locking the pool protection lock). And it can
+ skip the call to objc_mutex_lock/unlock too.
+ */
+ unsigned int recursive_usage_count;
+} *lock_node_ptr;
+
+
+/* The pools of locks. Each of them is a linked list of lock_nodes.
+ In the list we keep both unlocked and locked nodes.
+ */
+static lock_node_ptr sync_pool_array[SYNC_NUMBER_OF_POOLS];
+
+#ifndef SYNC_CACHE_DISABLE
+/* We store a cache of locks acquired by each thread in thread-local
+ storage.
+*/
+static __thread lock_node_ptr *lock_cache = NULL;
+
+/* This is a conservative implementation that uses a static array of
+ fixed size as cache. Because the cache is an array that we scan
+ linearly, the bigger it is, the slower it gets. This does not
+ matter much at small sizes (eg, the overhead of checking 8 cache
+ slots instead of 4 is very small compared to the other overheads
+ involved such as function calls and lock/unlock operations), but at
+ large sizes it becomes important as obviously there is a size over
+ which using the cache backfires: the lookup is so slow that the
+ cache slows down the software instead of speeding it up. In
+ practice, it seems that most threads use a small number of
+ concurrent locks, so we have a conservative implementation with a
+ fixed-size cache of 8 locks which gives a very predictable
+ behaviour. If a thread locks lots of different locks, only the
+ first 8 get the speed benefits of the cache, but the cache remains
+ always small, fast and predictable.
+
+ SYNC_CACHE_SIZE is the size of the lock cache for each thread.
+ */
+#define SYNC_CACHE_SIZE 8
+#endif /* SYNC_CACHE_DISABLE */
+
+/* Called at startup by init.c. */
+void
+__objc_sync_init (void)
+{
+ int i;
+
+ for (i = 0; i < SYNC_NUMBER_OF_POOLS; i++)
+ {
+ lock_node_ptr new_node;
+
+ /* Create a protection lock for each pool. */
+ sync_pool_protection_locks[i] = objc_mutex_allocate ();
+
+ /* Preallocate a lock per pool. */
+ new_node = objc_malloc (sizeof (struct lock_node));
+ new_node->lock = objc_mutex_allocate ();
+ new_node->object = nil;
+ new_node->usage_count = 0;
+ new_node->recursive_usage_count = 0;
+ new_node->next = NULL;
+
+ sync_pool_array[i] = new_node;
+ }
+}
+
+int
+objc_sync_enter (id object)
+{
+#ifndef SYNC_CACHE_DISABLE
+ int free_cache_slot;
+#endif
+ int hash;
+ lock_node_ptr node;
+ lock_node_ptr unused_node;
+
+ if (object == nil)
+ {
+ return OBJC_SYNC_SUCCESS;
+ }
+
+#ifndef SYNC_CACHE_DISABLE
+ if (lock_cache == NULL)
+ {
+ /* Note that this calloc only happen only once per thread, the
+ very first time a thread does a objc_sync_enter().
+ */
+ lock_cache = objc_calloc (SYNC_CACHE_SIZE, sizeof (lock_node_ptr));
+ }
+
+ /* Check the cache to see if we have a record of having already
+ locked the lock corresponding to this object. While doing so,
+ keep track of the first free cache node in case we need it later.
+ */
+ node = NULL;
+ free_cache_slot = -1;
+
+ {
+ int i;
+ for (i = 0; i < SYNC_CACHE_SIZE; i++)
+ {
+ lock_node_ptr locked_node = lock_cache[i];
+
+ if (locked_node == NULL)
+ {
+ if (free_cache_slot == -1)
+ {
+ free_cache_slot = i;
+ }
+ }
+ else if (locked_node->object == object)
+ {
+ node = locked_node;
+ break;
+ }
+ }
+ }
+
+ if (node != NULL)
+ {
+ /* We found the lock. Increase recursive_usage_count, which is
+ protected by node->lock, which we already hold.
+ */
+ node->recursive_usage_count++;
+
+ /* There is no need to actually lock anything, since we already
+ hold the lock. Correspondingly, objc_sync_exit() will just
+ decrease recursive_usage_count and do nothing to unlock.
+ */
+ return OBJC_SYNC_SUCCESS;
+ }
+#endif /* SYNC_CACHE_DISABLE */
+
+ /* The following is the standard lookup for the lock in the standard
+ pool lock. It requires a pool protection lock.
+ */
+ hash = SYNC_OBJECT_HASH(object);
+
+ /* Search for an existing lock for 'object'. While searching, make
+ note of any unused lock if we find any.
+ */
+ unused_node = NULL;
+
+ objc_mutex_lock (sync_pool_protection_locks[hash]);
+
+ node = sync_pool_array[hash];
+
+ while (node != NULL)
+ {
+ if (node->object == object)
+ {
+ /* We found the lock. */
+ node->usage_count++;
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+#ifndef SYNC_CACHE_DISABLE
+ /* Put it in the cache. */
+ if (free_cache_slot != -1)
+ {
+ lock_cache[free_cache_slot] = node;
+ }
+#endif
+
+ /* Lock it. */
+ objc_mutex_lock (node->lock);
+
+ return OBJC_SYNC_SUCCESS;
+ }
+
+ if (unused_node == NULL && node->usage_count == 0)
+ {
+ /* We found the first unused node. Record it. */
+ unused_node = node;
+ }
+
+ node = node->next;
+ }
+
+ /* An existing lock for 'object' could not be found. */
+ if (unused_node != NULL)
+ {
+ /* But we found a unused lock; use it. */
+ unused_node->object = object;
+ unused_node->usage_count = 1;
+ unused_node->recursive_usage_count = 0;
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+#ifndef SYNC_CACHE_DISABLE
+ if (free_cache_slot != -1)
+ {
+ lock_cache[free_cache_slot] = unused_node;
+ }
+#endif
+
+ objc_mutex_lock (unused_node->lock);
+
+ return OBJC_SYNC_SUCCESS;
+ }
+ else
+ {
+ /* There are no unused nodes; allocate a new node. */
+ lock_node_ptr new_node;
+
+ /* Create the node. */
+ new_node = objc_malloc (sizeof (struct lock_node));
+ new_node->lock = objc_mutex_allocate ();
+ new_node->object = object;
+ new_node->usage_count = 1;
+ new_node->recursive_usage_count = 0;
+
+ /* Attach it at the beginning of the pool. */
+ new_node->next = sync_pool_array[hash];
+ sync_pool_array[hash] = new_node;
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+#ifndef SYNC_CACHE_DISABLE
+ if (free_cache_slot != -1)
+ {
+ lock_cache[free_cache_slot] = new_node;
+ }
+#endif
+
+ objc_mutex_lock (new_node->lock);
+
+ return OBJC_SYNC_SUCCESS;
+ }
+}
+
+int
+objc_sync_exit (id object)
+{
+ int hash;
+ lock_node_ptr node;
+
+ if (object == nil)
+ {
+ return OBJC_SYNC_SUCCESS;
+ }
+
+#ifndef SYNC_CACHE_DISABLE
+ if (lock_cache != NULL)
+ {
+ int i;
+
+ /* Find the lock in the cache. */
+ node = NULL;
+ for (i = 0; i < SYNC_CACHE_SIZE; i++)
+ {
+ lock_node_ptr locked_node = lock_cache[i];
+
+ if (locked_node != NULL && locked_node->object == object)
+ {
+ node = locked_node;
+ break;
+ }
+ }
+ /* Note that, if a node was found in the cache, the variable i
+ now holds the index where it was found, which will be used to
+ remove it from the cache. */
+
+ if (node != NULL)
+ {
+ if (node->recursive_usage_count > 0)
+ {
+ node->recursive_usage_count--;
+ return OBJC_SYNC_SUCCESS;
+ }
+ else
+ {
+ /* We need to do a real unlock. */
+ hash = SYNC_OBJECT_HASH(object);
+
+ /* TODO: If we had atomic increase/decrease operations
+ with memory barriers, we could avoid the lock here!
+ */
+ objc_mutex_lock (sync_pool_protection_locks[hash]);
+ node->usage_count--;
+ /* Normally, we do not reset object to nil here. We'll
+ leave the lock associated with that object, at zero
+ usage count. This makes it slighly more efficient to
+ provide a lock for that object if (as likely)
+ requested again. If the object is deallocated, we
+ don't care. It will never match a new lock that is
+ requested, and the node will be reused at some point.
+
+ But, if garbage collection is enabled, leaving a
+ pointer to the object in memory might prevent the
+ object from being released. In that case, we remove
+ it (TODO: maybe we should avoid using the garbage
+ collector at all ? Nothing is ever deallocated in
+ this file).
+ */
+#if OBJC_WITH_GC
+ node->object = nil;
+#endif
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+ /* PS: Between objc_mutex_unlock
+ (sync_pool_protection_locks[hash]) and
+ objc_mutex_unlock (node->lock), the pool is unlocked
+ so other threads may allocate this same lock to
+ another object (!). This is not a problem, but it is
+ curious.
+ */
+ objc_mutex_unlock (node->lock);
+
+ /* Remove the node from the cache. */
+ lock_cache[i] = NULL;
+
+ return OBJC_SYNC_SUCCESS;
+ }
+ }
+ }
+#endif
+
+ /* The cache either wasn't there, or didn't work (eg, we overflowed
+ it at some point and stopped recording new locks in the cache).
+ Proceed with a full search of the lock pool. */
+ hash = SYNC_OBJECT_HASH(object);
+
+ objc_mutex_lock (sync_pool_protection_locks[hash]);
+
+ /* Search for an existing lock for 'object'. */
+ node = sync_pool_array[hash];
+
+ while (node != NULL)
+ {
+ if (node->object == object)
+ {
+ /* We found the lock. */
+ node->usage_count--;
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+ objc_mutex_unlock (node->lock);
+
+ /* No need to remove the node from the cache, since it
+ wasn't found in the cache when we looked for it!
+ */
+
+ return OBJC_SYNC_SUCCESS;
+ }
+
+ node = node->next;
+ }
+
+ objc_mutex_unlock (sync_pool_protection_locks[hash]);
+
+ /* A lock for 'object' to unlock could not be found (!!). */
+ return OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
+}
projects / platform / upstream / linaro-gcc.git / commitdiff