/* GNU Objective C Runtime class related functions
- Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Kresten Krab Thorup and Dennis Glatting.
-This file is part of GNU CC.
+ Lock-free class table code designed and written from scratch by
+ Nicola Pero, 2001.
-GNU CC is free software; you can redistribute it and/or modify it under the
+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 2, or (at your option) any later version.
+Foundation; either version 3, or (at your option) any later version.
-GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY
+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.
-You should have received a copy of the GNU General Public License along with
-GNU CC; see the file COPYING. If not, write to the Free Software
-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+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.
-/* As a special exception, if you link this library with files compiled with
- GCC to produce an executable, this does not cause the resulting executable
- to be covered by the GNU General Public License. This exception does not
- however invalidate any other reasons why the executable file might be
- covered by the GNU General Public License. */
+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/>. */
-#include "runtime.h" /* the kitchen sink */
-#include "sarray.h"
+/* The code in this file critically affects class method invocation
+ speed. This long preamble comment explains why, and the issues
+ involved.
-/* The table of classname->class. Used for objc_lookup_class and friends */
-static cache_ptr __objc_class_hash = 0; /* !T:MUTEX */
+ One of the traditional weaknesses of the GNU Objective-C runtime is
+ that class method invocations are slow. The reason is that when you
+ write
+
+ array = [NSArray new];
+
+ this gets basically compiled into the equivalent of
+
+ array = [(objc_get_class ("NSArray")) new];
+
+ objc_get_class returns the class pointer corresponding to the string
+ `NSArray'; and because of the lookup, the operation is more
+ complicated and slow than a simple instance method invocation.
+
+ Most high performance Objective-C code (using the GNU Objc runtime)
+ I had the opportunity to read (or write) work around this problem by
+ caching the class pointer:
+
+ Class arrayClass = [NSArray class];
+
+ ... later on ...
+
+ array = [arrayClass new];
+ array = [arrayClass new];
+ array = [arrayClass new];
+
+ In this case, you always perform a class lookup (the first one), but
+ then all the [arrayClass new] methods run exactly as fast as an
+ instance method invocation. It helps if you have many class method
+ invocations to the same class.
+
+ The long-term solution to this problem would be to modify the
+ compiler to output tables of class pointers corresponding to all the
+ class method invocations, and to add code to the runtime to update
+ these tables - that should in the end allow class method invocations
+ to perform precisely as fast as instance method invocations, because
+ no class lookup would be involved. I think the Apple Objective-C
+ runtime uses this technique. Doing this involves synchronized
+ modifications in the runtime and in the compiler.
+
+ As a first medicine to the problem, I [NP] have redesigned and
+ rewritten the way the runtime is performing class lookup. This
+ doesn't give as much speed as the other (definitive) approach, but
+ at least a class method invocation now takes approximately 4.5 times
+ an instance method invocation on my machine (it would take approx 12
+ times before the rewriting), which is a lot better.
+
+ One of the main reason the new class lookup is so faster is because
+ I implemented it in a way that can safely run multithreaded without
+ using locks - a so-called `lock-free' data structure. The atomic
+ operation is pointer assignment. The reason why in this problem
+ lock-free data structures work so well is that you never remove
+ classes from the table - and the difficult thing with lock-free data
+ structures is freeing data when is removed from the structures. */
+
+#include "objc-private/common.h"
+#include "objc-private/error.h"
+#include "objc/runtime.h"
+#include "objc/thr.h"
+#include "objc-private/module-abi-8.h" /* For CLS_ISCLASS and similar. */
+#include "objc-private/runtime.h" /* the kitchen sink */
+#include "objc-private/sarray.h" /* For sarray_put_at_safe. */
+#include "objc-private/selector.h" /* For sarray_put_at_safe. */
+#include <string.h> /* For memset */
+
+/* We use a table which maps a class name to the corresponding class
+ pointer. The first part of this file defines this table, and
+ functions to do basic operations on the table. The second part of
+ the file implements some higher level Objective-C functionality for
+ classes by using the functions provided in the first part to manage
+ the table. */
+
+/**
+ ** Class Table Internals
+ **/
+
+/* A node holding a class */
+typedef struct class_node
+{
+ struct class_node *next; /* Pointer to next entry on the list.
+ NULL indicates end of list. */
+
+ const char *name; /* The class name string */
+ int length; /* The class name string length */
+ Class pointer; /* The Class pointer */
+
+} *class_node_ptr;
+
+/* A table containing classes is a class_node_ptr (pointing to the
+ first entry in the table - if it is NULL, then the table is
+ empty). */
+
+/* We have 1024 tables. Each table contains all class names which
+ have the same hash (which is a number between 0 and 1023). To look
+ up a class_name, we compute its hash, and get the corresponding
+ table. Once we have the table, we simply compare strings directly
+ till we find the one which we want (using the length first). The
+ number of tables is quite big on purpose (a normal big application
+ has less than 1000 classes), so that you shouldn't normally get any
+ collisions, and get away with a single comparison (which we can't
+ avoid since we need to know that you have got the right thing). */
+#define CLASS_TABLE_SIZE 1024
+#define CLASS_TABLE_MASK 1023
+
+static class_node_ptr class_table_array[CLASS_TABLE_SIZE];
+
+/* The table writing mutex - we lock on writing to avoid conflicts
+ between different writers, but we read without locks. That is
+ possible because we assume pointer assignment to be an atomic
+ operation. TODO: This is only true under certain circumstances,
+ which should be clarified. */
+static objc_mutex_t __class_table_lock = NULL;
+
+/* CLASS_TABLE_HASH is how we compute the hash of a class name. It is
+ a macro - *not* a function - arguments *are* modified directly.
+
+ INDEX should be a variable holding an int;
+ HASH should be a variable holding an int;
+ CLASS_NAME should be a variable holding a (char *) to the class_name.
+
+ After the macro is executed, INDEX contains the length of the
+ string, and HASH the computed hash of the string; CLASS_NAME is
+ untouched. */
+
+#define CLASS_TABLE_HASH(INDEX, HASH, CLASS_NAME) \
+ HASH = 0; \
+ for (INDEX = 0; CLASS_NAME[INDEX] != '\0'; INDEX++) \
+ { \
+ HASH = (HASH << 4) ^ (HASH >> 28) ^ CLASS_NAME[INDEX]; \
+ } \
+ \
+ HASH = (HASH ^ (HASH >> 10) ^ (HASH >> 20)) & CLASS_TABLE_MASK;
+
+/* Setup the table. */
+static void
+class_table_setup (void)
+{
+ /* Start - nothing in the table. */
+ memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE);
-/* This is a hook which is called by objc_get_class and
- objc_lookup_class if the runtime is not able to find the class.
- This may e.g. try to load in the class using dynamic loading */
-Class (*_objc_lookup_class)(const char* name) = 0; /* !T:SAFE */
+ /* The table writing mutex. */
+ __class_table_lock = objc_mutex_allocate ();
+}
-/* True when class links has been resolved */
-BOOL __objc_class_links_resolved = NO; /* !T:UNUSED */
+/* Insert a class in the table (used when a new class is
+ registered). */
+static void
+class_table_insert (const char *class_name, Class class_pointer)
+{
+ int hash, length;
+ class_node_ptr new_node;
+ /* Find out the class name's hash and length. */
+ CLASS_TABLE_HASH (length, hash, class_name);
+
+ /* Prepare the new node holding the class. */
+ new_node = objc_malloc (sizeof (struct class_node));
+ new_node->name = class_name;
+ new_node->length = length;
+ new_node->pointer = class_pointer;
+
+ /* Lock the table for modifications. */
+ objc_mutex_lock (__class_table_lock);
+
+ /* Insert the new node in the table at the beginning of the table at
+ class_table_array[hash]. */
+ new_node->next = class_table_array[hash];
+ class_table_array[hash] = new_node;
+
+ objc_mutex_unlock (__class_table_lock);
+}
-/* Initial number of buckets size of class hash table. */
-#define CLASS_HASH_SIZE 32
+/* Get a class from the table. This does not need mutex protection.
+ Currently, this function is called each time you call a static
+ method, this is why it must be very fast. */
+static inline Class
+class_table_get_safe (const char *class_name)
+{
+ class_node_ptr node;
+ int length, hash;
-void __objc_init_class_tables()
+ /* Compute length and hash. */
+ CLASS_TABLE_HASH (length, hash, class_name);
+
+ node = class_table_array[hash];
+
+ if (node != NULL)
+ {
+ do
+ {
+ if (node->length == length)
+ {
+ /* Compare the class names. */
+ int i;
+
+ for (i = 0; i < length; i++)
+ {
+ if ((node->name)[i] != class_name[i])
+ break;
+ }
+
+ if (i == length)
+ {
+ /* They are equal! */
+ return node->pointer;
+ }
+ }
+ }
+ while ((node = node->next) != NULL);
+ }
+
+ return Nil;
+}
+
+/* Enumerate over the class table. */
+struct class_table_enumerator
{
- /* Allocate the class hash table */
+ int hash;
+ class_node_ptr node;
+};
- if(__objc_class_hash)
- return;
- objc_mutex_lock(__objc_runtime_mutex);
+static Class
+class_table_next (struct class_table_enumerator **e)
+{
+ struct class_table_enumerator *enumerator = *e;
+ class_node_ptr next;
+
+ if (enumerator == NULL)
+ {
+ *e = objc_malloc (sizeof (struct class_table_enumerator));
+ enumerator = *e;
+ enumerator->hash = 0;
+ enumerator->node = NULL;
- __objc_class_hash
- = hash_new (CLASS_HASH_SIZE,
- (hash_func_type) hash_string,
- (compare_func_type) compare_strings);
+ next = class_table_array[enumerator->hash];
+ }
+ else
+ next = enumerator->node->next;
+
+ if (next != NULL)
+ {
+ enumerator->node = next;
+ return enumerator->node->pointer;
+ }
+ else
+ {
+ enumerator->hash++;
+
+ while (enumerator->hash < CLASS_TABLE_SIZE)
+ {
+ next = class_table_array[enumerator->hash];
+ if (next != NULL)
+ {
+ enumerator->node = next;
+ return enumerator->node->pointer;
+ }
+ enumerator->hash++;
+ }
+
+ /* Ok - table finished - done. */
+ objc_free (enumerator);
+ return Nil;
+ }
+}
- objc_mutex_unlock(__objc_runtime_mutex);
-}
+#if 0 /* DEBUGGING FUNCTIONS */
+/* Debugging function - print the class table. */
+void
+class_table_print (void)
+{
+ int i;
+
+ for (i = 0; i < CLASS_TABLE_SIZE; i++)
+ {
+ class_node_ptr node;
+
+ printf ("%d:\n", i);
+ node = class_table_array[i];
+
+ while (node != NULL)
+ {
+ printf ("\t%s\n", node->name);
+ node = node->next;
+ }
+ }
+}
-/* This function adds a class to the class hash table, and assigns the
- class a number, unless it's already known */
+/* Debugging function - print an histogram of number of classes in
+ function of hash key values. Useful to evaluate the hash function
+ in real cases. */
void
-__objc_add_class_to_hash(Class class)
+class_table_print_histogram (void)
{
- Class h_class;
+ int i, j;
+ int counter = 0;
+
+ for (i = 0; i < CLASS_TABLE_SIZE; i++)
+ {
+ class_node_ptr node;
+
+ node = class_table_array[i];
+
+ while (node != NULL)
+ {
+ counter++;
+ node = node->next;
+ }
+ if (((i + 1) % 50) == 0)
+ {
+ printf ("%4d:", i + 1);
+ for (j = 0; j < counter; j++)
+ printf ("X");
+
+ printf ("\n");
+ counter = 0;
+ }
+ }
+ printf ("%4d:", i + 1);
+ for (j = 0; j < counter; j++)
+ printf ("X");
+
+ printf ("\n");
+}
+#endif /* DEBUGGING FUNCTIONS */
+
+/**
+ ** Objective-C runtime functions
+ **/
+
+/* From now on, the only access to the class table data structure
+ should be via the class_table_* functions. */
+
+/* This is a hook which is called by objc_get_class and
+ objc_lookup_class if the runtime is not able to find the class.
+ This may e.g. try to load in the class using dynamic loading.
+
+ This hook was a public, global variable in the Traditional GNU
+ Objective-C Runtime API (objc/objc-api.h). The modern GNU
+ Objective-C Runtime API (objc/runtime.h) provides the
+ objc_setGetUnknownClassHandler() function instead.
+*/
+Class (*_objc_lookup_class) (const char *name) = 0; /* !T:SAFE */
+
+/* The handler currently in use. PS: if both
+ __obj_get_unknown_class_handler and _objc_lookup_class are defined,
+ __objc_get_unknown_class_handler is called first. */
+static objc_get_unknown_class_handler
+__objc_get_unknown_class_handler = NULL;
+
+objc_get_unknown_class_handler
+objc_setGetUnknownClassHandler (objc_get_unknown_class_handler
+ new_handler)
+{
+ objc_get_unknown_class_handler old_handler
+ = __objc_get_unknown_class_handler;
+ __objc_get_unknown_class_handler = new_handler;
+ return old_handler;
+}
+
+
+/* True when class links has been resolved. */
+BOOL __objc_class_links_resolved = NO; /* !T:UNUSED */
+
+
+void
+__objc_init_class_tables (void)
+{
+ /* Allocate the class hash table. */
+
+ if (__class_table_lock)
+ return;
+
+ objc_mutex_lock (__objc_runtime_mutex);
+
+ class_table_setup ();
+
+ objc_mutex_unlock (__objc_runtime_mutex);
+}
- objc_mutex_lock(__objc_runtime_mutex);
+/* This function adds a class to the class hash table, and assigns the
+ class a number, unless it's already known. Return 'YES' if the
+ class was added. Return 'NO' if the class was already known. */
+BOOL
+__objc_add_class_to_hash (Class class)
+{
+ Class existing_class;
+
+ objc_mutex_lock (__objc_runtime_mutex);
- /* make sure the table is there */
- assert(__objc_class_hash);
+ /* Make sure the table is there. */
+ assert (__class_table_lock);
- /* make sure it's not a meta class */
- assert(CLS_ISCLASS(class));
+ /* Make sure it's not a meta class. */
+ assert (CLS_ISCLASS (class));
/* Check to see if the class is already in the hash table. */
- h_class = hash_value_for_key (__objc_class_hash, class->name);
- if (!h_class)
+ existing_class = class_table_get_safe (class->name);
+
+ if (existing_class)
{
- /* The class isn't in the hash table. Add the class and assign a class
- number. */
+ objc_mutex_unlock (__objc_runtime_mutex);
+ return NO;
+ }
+ else
+ {
+ /* The class isn't in the hash table. Add the class and assign
+ a class number. */
static unsigned int class_number = 1;
-
- CLS_SETNUMBER(class, class_number);
- CLS_SETNUMBER(class->class_pointer, class_number);
+
+ CLS_SETNUMBER (class, class_number);
+ CLS_SETNUMBER (class->class_pointer, class_number);
++class_number;
- hash_add (&__objc_class_hash, class->name, class);
- }
+ class_table_insert (class->name, class);
- objc_mutex_unlock(__objc_runtime_mutex);
+ objc_mutex_unlock (__objc_runtime_mutex);
+ return YES;
+ }
}
-/* Get the class object for the class named NAME. If NAME does not
- identify a known class, the hook _objc_lookup_class is called. If
- this fails, nil is returned */
-Class objc_lookup_class (const char* name)
+Class
+objc_getClass (const char *name)
{
Class class;
- objc_mutex_lock(__objc_runtime_mutex);
+ if (name == NULL)
+ return Nil;
+
+ class = class_table_get_safe (name);
+
+ if (class)
+ return class;
- /* Make sure the class hash table exists. */
- assert (__objc_class_hash);
+ if (__objc_get_unknown_class_handler)
+ return (*__objc_get_unknown_class_handler) (name);
- class = hash_value_for_key (__objc_class_hash, name);
+ if (_objc_lookup_class)
+ return (*_objc_lookup_class) (name);
- objc_mutex_unlock(__objc_runtime_mutex);
+ return Nil;
+}
+
+Class
+objc_lookUpClass (const char *name)
+{
+ if (name == NULL)
+ return Nil;
+ else
+ return class_table_get_safe (name);
+}
+
+Class
+objc_getMetaClass (const char *name)
+{
+ Class class = objc_getClass (name);
+
+ if (class)
+ return class->class_pointer;
+ else
+ return Nil;
+}
+
+Class
+objc_getRequiredClass (const char *name)
+{
+ Class class = objc_getClass (name);
if (class)
return class;
+ else
+ _objc_abort ("objc_getRequiredClass ('%s') failed: class not found\n", name);
+}
- if (_objc_lookup_class)
- return (*_objc_lookup_class)(name);
+int
+objc_getClassList (Class *returnValue, int maxNumberOfClassesToReturn)
+{
+ /* Iterate over all entries in the table. */
+ int hash, count = 0;
+
+ for (hash = 0; hash < CLASS_TABLE_SIZE; hash++)
+ {
+ class_node_ptr node = class_table_array[hash];
+
+ while (node != NULL)
+ {
+ if (returnValue)
+ {
+ if (count < maxNumberOfClassesToReturn)
+ returnValue[count] = node->pointer;
+ else
+ return count;
+ }
+ count++;
+ node = node->next;
+ }
+ }
+
+ return count;
+}
+
+Class
+objc_allocateClassPair (Class super_class, const char *class_name, size_t extraBytes)
+{
+ Class new_class;
+ Class new_meta_class;
+
+ if (class_name == NULL)
+ return Nil;
+
+ if (objc_getClass (class_name))
+ return Nil;
+
+ if (super_class)
+ {
+ /* If you want to build a hierarchy of classes, you need to
+ build and register them one at a time. The risk is that you
+ are able to cause confusion by registering a subclass before
+ the superclass or similar. */
+ if (CLS_IS_IN_CONSTRUCTION (super_class))
+ return Nil;
+ }
+
+ /* Technically, we should create the metaclass first, then use
+ class_createInstance() to create the class. That complication
+ would be relevant if we had class variables, but we don't, so we
+ just ignore it and create everything directly and assume all
+ classes have the same size. */
+ new_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes);
+ new_meta_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes);
+
+ /* We create an unresolved class, similar to one generated by the
+ compiler. It will be resolved later when we register it.
+
+ Note how the metaclass details are not that important; when the
+ class is resolved, the ones that matter will be fixed up. */
+ new_class->class_pointer = new_meta_class;
+ new_meta_class->class_pointer = 0;
+
+ if (super_class)
+ {
+ /* Force the name of the superclass in place of the link to the
+ actual superclass, which will be put there when the class is
+ resolved. */
+ const char *super_class_name = class_getName (super_class);
+ new_class->super_class = (void *)super_class_name;
+ new_meta_class->super_class = (void *)super_class_name;
+ }
else
- return 0;
+ {
+ new_class->super_class = (void *)0;
+ new_meta_class->super_class = (void *)0;
+ }
+
+ new_class->name = objc_malloc (strlen (class_name) + 1);
+ strcpy ((char*)new_class->name, class_name);
+ new_meta_class->name = new_class->name;
+
+ new_class->version = 0;
+ new_meta_class->version = 0;
+
+ new_class->info = _CLS_CLASS | _CLS_IN_CONSTRUCTION;
+ new_meta_class->info = _CLS_META | _CLS_IN_CONSTRUCTION;
+
+ if (super_class)
+ new_class->instance_size = super_class->instance_size;
+ else
+ new_class->instance_size = 0;
+ new_meta_class->instance_size = sizeof (struct objc_class);
+
+ return new_class;
+}
+
+void
+objc_registerClassPair (Class class_)
+{
+ if (class_ == Nil)
+ return;
+
+ if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_)))
+ return;
+
+ if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer)))
+ return;
+
+ objc_mutex_lock (__objc_runtime_mutex);
+
+ if (objc_getClass (class_->name))
+ {
+ objc_mutex_unlock (__objc_runtime_mutex);
+ return;
+ }
+
+ CLS_SET_NOT_IN_CONSTRUCTION (class_);
+ CLS_SET_NOT_IN_CONSTRUCTION (class_->class_pointer);
+
+ __objc_init_class (class_);
+
+ /* Resolve class links immediately. No point in waiting. */
+ __objc_resolve_class_links ();
+
+ objc_mutex_unlock (__objc_runtime_mutex);
+}
+
+void
+objc_disposeClassPair (Class class_)
+{
+ if (class_ == Nil)
+ return;
+
+ if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_)))
+ return;
+
+ if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer)))
+ return;
+
+ /* Undo any class_addIvar(). */
+ if (class_->ivars)
+ {
+ int i;
+ for (i = 0; i < class_->ivars->ivar_count; i++)
+ {
+ struct objc_ivar *ivar = &(class_->ivars->ivar_list[i]);
+
+ objc_free ((char *)ivar->ivar_name);
+ objc_free ((char *)ivar->ivar_type);
+ }
+
+ objc_free (class_->ivars);
+ }
+
+ /* Undo any class_addMethod(). */
+ if (class_->methods)
+ {
+ struct objc_method_list *list = class_->methods;
+ while (list)
+ {
+ int i;
+ struct objc_method_list *next = list->method_next;
+
+ for (i = 0; i < list->method_count; i++)
+ {
+ struct objc_method *method = &(list->method_list[i]);
+
+ objc_free ((char *)method->method_name);
+ objc_free ((char *)method->method_types);
+ }
+
+ objc_free (list);
+ list = next;
+ }
+ }
+
+ /* Undo any class_addProtocol(). */
+ if (class_->protocols)
+ {
+ struct objc_protocol_list *list = class_->protocols;
+ while (list)
+ {
+ struct objc_protocol_list *next = list->next;
+
+ objc_free (list);
+ list = next;
+ }
+ }
+
+ /* Undo any class_addMethod() on the meta-class. */
+ if (class_->class_pointer->methods)
+ {
+ struct objc_method_list *list = class_->class_pointer->methods;
+ while (list)
+ {
+ int i;
+ struct objc_method_list *next = list->method_next;
+
+ for (i = 0; i < list->method_count; i++)
+ {
+ struct objc_method *method = &(list->method_list[i]);
+
+ objc_free ((char *)method->method_name);
+ objc_free ((char *)method->method_types);
+ }
+
+ objc_free (list);
+ list = next;
+ }
+ }
+
+ /* Undo objc_allocateClassPair(). */
+ objc_free ((char *)(class_->name));
+ objc_free (class_->class_pointer);
+ objc_free (class_);
}
+/* Traditional GNU Objective-C Runtime API. Important: this method is
+ called automatically by the compiler while messaging (if using the
+ traditional ABI), so it is worth keeping it fast; don't make it
+ just a wrapper around objc_getClass(). */
+/* Note that this is roughly equivalent to objc_getRequiredClass(). */
/* Get the class object for the class named NAME. If NAME does not
identify a known class, the hook _objc_lookup_class is called. If
- this fails, an error message is issued and the system aborts */
+ this fails, an error message is issued and the system aborts. */
Class
objc_get_class (const char *name)
{
Class class;
- objc_mutex_lock(__objc_runtime_mutex);
-
- /* Make sure the class hash table exists. */
- assert (__objc_class_hash);
-
- class = hash_value_for_key (__objc_class_hash, name);
-
- objc_mutex_unlock(__objc_runtime_mutex);
+ class = class_table_get_safe (name);
if (class)
return class;
- if (_objc_lookup_class)
- class = (*_objc_lookup_class)(name);
+ if (__objc_get_unknown_class_handler)
+ class = (*__objc_get_unknown_class_handler) (name);
- if(class)
+ if ((!class) && _objc_lookup_class)
+ class = (*_objc_lookup_class) (name);
+
+ if (class)
return class;
- objc_error(nil, OBJC_ERR_BAD_CLASS,
- "objc runtime: cannot find class %s\n", name);
+ _objc_abort ("objc runtime: cannot find class %s\n", name);
+
return 0;
}
-MetaClass
-objc_get_meta_class(const char *name)
+/* This is used by the compiler too. */
+Class
+objc_get_meta_class (const char *name)
{
- return objc_get_class(name)->class_pointer;
+ return objc_get_class (name)->class_pointer;
}
-/* This function provides a way to enumerate all the classes in the
- executable. Pass *ENUM_STATE == NULL to start the enumeration. The
- function will return 0 when there are no more classes.
- For example:
- id class;
- void *es = NULL;
- while ((class = objc_next_class(&es)))
- ... do something with class;
-*/
+/* This is not used by GCC, but the clang compiler seems to use it
+ when targetting the GNU runtime. That's wrong, but we have it to
+ be compatible. */
Class
-objc_next_class(void **enum_state)
+objc_lookup_class (const char *name)
{
- objc_mutex_lock(__objc_runtime_mutex);
-
- /* make sure the table is there */
- assert(__objc_class_hash);
-
- *(node_ptr*)enum_state =
- hash_next(__objc_class_hash, *(node_ptr*)enum_state);
+ return objc_getClass (name);
+}
- objc_mutex_unlock(__objc_runtime_mutex);
+/* This is used when the implementation of a method changes. It goes
+ through all classes, looking for the ones that have these methods
+ (either method_a or method_b; method_b can be NULL), and reloads
+ the implementation for these. You should call this with the
+ runtime mutex already locked. */
+void
+__objc_update_classes_with_methods (struct objc_method *method_a, struct objc_method *method_b)
+{
+ int hash;
- if (*(node_ptr*)enum_state)
- return (*(node_ptr*)enum_state)->value;
- return (Class)0;
+ /* Iterate over all classes. */
+ for (hash = 0; hash < CLASS_TABLE_SIZE; hash++)
+ {
+ class_node_ptr node = class_table_array[hash];
+
+ while (node != NULL)
+ {
+ /* We execute this loop twice: the first time, we iterate
+ over all methods in the class (instance methods), while
+ the second time we iterate over all methods in the meta
+ class (class methods). */
+ Class class = Nil;
+ BOOL done = NO;
+
+ while (done == NO)
+ {
+ struct objc_method_list * method_list;
+
+ if (class == Nil)
+ {
+ /* The first time, we work on the class. */
+ class = node->pointer;
+ }
+ else
+ {
+ /* The second time, we work on the meta class. */
+ class = class->class_pointer;
+ done = YES;
+ }
+
+ method_list = class->methods;
+
+ while (method_list)
+ {
+ int i;
+
+ for (i = 0; i < method_list->method_count; ++i)
+ {
+ struct objc_method *method = &method_list->method_list[i];
+
+ /* If the method is one of the ones we are
+ looking for, update the implementation. */
+ if (method == method_a)
+ sarray_at_put_safe (class->dtable,
+ (sidx) method_a->method_name->sel_id,
+ method_a->method_imp);
+
+ if (method == method_b)
+ {
+ if (method_b != NULL)
+ sarray_at_put_safe (class->dtable,
+ (sidx) method_b->method_name->sel_id,
+ method_b->method_imp);
+ }
+ }
+
+ method_list = method_list->method_next;
+ }
+ }
+ node = node->next;
+ }
+ }
}
-/* Resolve super/subclass links for all classes. The only thing we
- can be sure of is that the class_pointer for class objects point
- to the right meta class objects */
-void __objc_resolve_class_links()
+/* Resolve super/subclass links for all classes. The only thing we
+ can be sure of is that the class_pointer for class objects point to
+ the right meta class objects. */
+void
+__objc_resolve_class_links (void)
{
- node_ptr node;
+ struct class_table_enumerator *es = NULL;
Class object_class = objc_get_class ("Object");
+ Class class1;
- assert(object_class);
+ assert (object_class);
- objc_mutex_lock(__objc_runtime_mutex);
+ objc_mutex_lock (__objc_runtime_mutex);
- /* Assign subclass links */
- for (node = hash_next (__objc_class_hash, NULL); node;
- node = hash_next (__objc_class_hash, node))
+ /* Assign subclass links. */
+ while ((class1 = class_table_next (&es)))
{
- Class class1 = node->value;
-
/* Make sure we have what we think we have. */
- assert (CLS_ISCLASS(class1));
- assert (CLS_ISMETA(class1->class_pointer));
+ assert (CLS_ISCLASS (class1));
+ assert (CLS_ISMETA (class1->class_pointer));
- /* The class_pointer of all meta classes point to Object's meta class. */
+ /* The class_pointer of all meta classes point to Object's meta
+ class. */
class1->class_pointer->class_pointer = object_class->class_pointer;
- if (!(CLS_ISRESOLV(class1)))
+ if (! CLS_ISRESOLV (class1))
{
- CLS_SETRESOLV(class1);
- CLS_SETRESOLV(class1->class_pointer);
+ CLS_SETRESOLV (class1);
+ CLS_SETRESOLV (class1->class_pointer);
- if(class1->super_class)
+ if (class1->super_class)
{
Class a_super_class
= objc_get_class ((char *) class1->super_class);
DEBUG_PRINTF ("making class connections for: %s\n",
class1->name);
- /* assign subclass links for superclass */
+ /* Assign subclass links for superclass. */
class1->sibling_class = a_super_class->subclass_list;
a_super_class->subclass_list = class1;
- /* Assign subclass links for meta class of superclass */
+ /* Assign subclass links for meta class of superclass. */
if (a_super_class->class_pointer)
{
class1->class_pointer->sibling_class
= class1->class_pointer;
}
}
- else /* a root class, make its meta object */
- /* be a subclass of Object */
+ else /* A root class, make its meta object be a subclass of
+ Object. */
{
class1->class_pointer->sibling_class
= object_class->subclass_list;
}
}
- /* Assign superclass links */
- for (node = hash_next (__objc_class_hash, NULL); node;
- node = hash_next (__objc_class_hash, node))
+ /* Assign superclass links. */
+ es = NULL;
+ while ((class1 = class_table_next (&es)))
{
- Class class1 = node->value;
Class sub_class;
for (sub_class = class1->subclass_list; sub_class;
sub_class = sub_class->sibling_class)
{
sub_class->super_class = class1;
- if(CLS_ISCLASS(sub_class))
+ if (CLS_ISCLASS (sub_class))
sub_class->class_pointer->super_class = class1->class_pointer;
}
}
- objc_mutex_unlock(__objc_runtime_mutex);
+ objc_mutex_unlock (__objc_runtime_mutex);
}
+const char *
+class_getName (Class class_)
+{
+ if (class_ == Nil)
+ return "nil";
+ return class_->name;
+}
-#define CLASSOF(c) ((c)->class_pointer)
+BOOL
+class_isMetaClass (Class class_)
+{
+ /* CLS_ISMETA includes the check for Nil class_. */
+ return CLS_ISMETA (class_);
+}
+/* Even inside libobjc it may be worth using class_getSuperclass
+ instead of accessing class_->super_class directly because it
+ resolves the class links if needed. If you access
+ class_->super_class directly, make sure to deal with the situation
+ where the class is not resolved yet! */
Class
-class_pose_as (Class impostor, Class super_class)
+class_getSuperclass (Class class_)
{
- node_ptr node;
- Class class1;
+ if (class_ == Nil)
+ return Nil;
+
+ /* Classes that are in construction are not resolved, and still have
+ the class name (instead of a class pointer) in the
+ class_->super_class field. In that case we need to lookup the
+ superclass name to return the superclass. We can not resolve the
+ class until it is registered. */
+ if (CLS_IS_IN_CONSTRUCTION (class_))
+ {
+ if (CLS_ISMETA (class_))
+ return object_getClass ((id)objc_lookUpClass ((const char *)(class_->super_class)));
+ else
+ return objc_lookUpClass ((const char *)(class_->super_class));
+ }
- if (!CLS_ISRESOLV (impostor))
+ /* If the class is not resolved yet, super_class would point to a
+ string (the name of the super class) as opposed to the actual
+ super class. In that case, we need to resolve the class links
+ before we can return super_class. */
+ if (! CLS_ISRESOLV (class_))
__objc_resolve_class_links ();
-
- /* preconditions */
- assert (impostor);
- assert (super_class);
- assert (impostor->super_class == super_class);
- assert (CLS_ISCLASS (impostor));
- assert (CLS_ISCLASS (super_class));
- assert (impostor->instance_size == super_class->instance_size);
-
- {
- Class *subclass = &(super_class->subclass_list);
-
- /* move subclasses of super_class to impostor */
- while (*subclass)
- {
- Class nextSub = (*subclass)->sibling_class;
-
- if (*subclass != impostor)
- {
- Class sub = *subclass;
-
- /* classes */
- sub->sibling_class = impostor->subclass_list;
- sub->super_class = impostor;
- impostor->subclass_list = sub;
-
- /* It will happen that SUB is not a class object if it is
- the top of the meta class hierarchy chain. (root
- meta-class objects inherit their class object) If that is
- the case... don't mess with the meta-meta class. */
- if (CLS_ISCLASS (sub))
- {
- /* meta classes */
- CLASSOF (sub)->sibling_class =
- CLASSOF (impostor)->subclass_list;
- CLASSOF (sub)->super_class = CLASSOF (impostor);
- CLASSOF (impostor)->subclass_list = CLASSOF (sub);
- }
- }
-
- *subclass = nextSub;
- }
-
- /* set subclasses of superclass to be impostor only */
- super_class->subclass_list = impostor;
- CLASSOF (super_class)->subclass_list = CLASSOF (impostor);
-
- /* set impostor to have no sibling classes */
- impostor->sibling_class = 0;
- CLASSOF (impostor)->sibling_class = 0;
- }
- /* check relationship of impostor and super_class is kept. */
- assert (impostor->super_class == super_class);
- assert (CLASSOF (impostor)->super_class == CLASSOF (super_class));
+ return class_->super_class;
+}
- /* This is how to update the lookup table. Regardless of
- what the keys of the hashtable is, change all values that are
- superclass into impostor. */
+int
+class_getVersion (Class class_)
+{
+ if (class_ == Nil)
+ return 0;
- objc_mutex_lock(__objc_runtime_mutex);
+ return (int)(class_->version);
+}
- for (node = hash_next (__objc_class_hash, NULL); node;
- node = hash_next (__objc_class_hash, node))
- {
- class1 = (Class)node->value;
- if (class1 == super_class)
- {
- node->value = impostor; /* change hash table value */
- }
- }
+void
+class_setVersion (Class class_, int version)
+{
+ if (class_ == Nil)
+ return;
- objc_mutex_unlock(__objc_runtime_mutex);
+ class_->version = version;
+}
- /* next, we update the dispatch tables... */
- __objc_update_dispatch_table_for_class (CLASSOF (impostor));
- __objc_update_dispatch_table_for_class (impostor);
+size_t
+class_getInstanceSize (Class class_)
+{
+ if (class_ == Nil)
+ return 0;
- return impostor;
+ return class_->instance_size;
}
-
OSDN Git Service
