diff options
Diffstat (limited to 'gcc-4.7/libobjc/init.c')
| -rw-r--r-- | gcc-4.7/libobjc/init.c | 1044 |
1 files changed, 1044 insertions, 0 deletions
diff --git a/gcc-4.7/libobjc/init.c b/gcc-4.7/libobjc/init.c new file mode 100644 index 000000000..23ba41ba1 --- /dev/null +++ b/gcc-4.7/libobjc/init.c @@ -0,0 +1,1044 @@ +/* GNU Objective C Runtime initialization + Copyright (C) 1993, 1995, 1996, 1997, 2002, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Kresten Krab Thorup + +load support contributed by Ovidiu Predescu <ovidiu@net-community.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/>. */ + +/* Uncommented the following line to enable debug logging. Use this + only while debugging the runtime. */ +/* #define DEBUG 1 */ + +#include "objc-private/common.h" +#include "objc-private/error.h" +#include "objc/runtime.h" +#include "objc/thr.h" +#include "objc-private/hash.h" +#include "objc-private/objc-list.h" +#include "objc-private/module-abi-8.h" +#include "objc-private/runtime.h" /* For __objc_resolve_class_links(). */ +#include "objc-private/selector.h" /* For __sel_register_typed_name(). */ +#include "objc-private/objc-sync.h" /* For __objc_sync_init() */ +#include "objc-private/protocols.h" /* For __objc_protocols_init(), + __objc_protocols_add_protocol() + __objc_protocols_register_selectors() */ +#include "objc-private/accessors.h" /* For __objc_accessors_init() */ + +/* The version number of this runtime. This must match the number + defined in gcc (objc-act.c). */ +#define OBJC_VERSION 8 +#define PROTOCOL_VERSION 2 + +/* This list contains modules currently loaded into the runtime and + for which the +load method (and the load callback, if any) has not + been called yet. */ +static struct objc_list *__objc_module_list = 0; /* !T:MUTEX */ + +/* This list contains all proto_list's not yet assigned class + links. */ +static struct objc_list *unclaimed_proto_list = 0; /* !T:MUTEX */ + +/* List of unresolved static instances. */ +static struct objc_list *uninitialized_statics = 0; /* !T:MUTEX */ + +/* List of duplicated classes found while loading modules. If we find + a class twice, we ignore it the second time. On some platforms, + where the order in which modules are loaded is well defined, this + allows you to replace a class in a shared library by linking in a + new implementation which is loaded in in the right order, and which + overrides the existing one. + + Protected by __objc_runtime_mutex. */ +static cache_ptr duplicate_classes = NULL; + +/* Global runtime "write" mutex. Having a single mutex prevents + deadlocks, but reduces concurrency. To improve concurrency, some + groups of functions in the runtime have their own separate mutex + (eg, __class_table_lock in class.c); to avoid deadlocks, these + routines must make sure that they never acquire any other lock + while holding their own local lock. Ie, they should lock, execute + some C code that does not perform any calls to other runtime + functions which may potentially lock different locks, then unlock. + If they need to perform any calls to other runtime functions that + may potentially lock other locks, then they should use the global + __objc_runtime_mutex. */ +objc_mutex_t __objc_runtime_mutex = 0; + +/* Number of threads that are alive. */ +int __objc_runtime_threads_alive = 1; /* !T:MUTEX */ + +/* Check compiler vs runtime version. */ +static void init_check_module_version (struct objc_module *); + +/* Assign isa links to protos. */ +static void __objc_init_protocols (struct objc_protocol_list *protos); + +/* Assign isa link to a protocol, and register it. */ +static void __objc_init_protocol (struct objc_protocol *protocol); + +/* Add protocol to class. */ +static void __objc_class_add_protocols (Class, struct objc_protocol_list *); + +/* Load callback hook. */ +void (*_objc_load_callback) (Class class, struct objc_category *category) = 0; /* !T:SAFE */ + +/* Are all categories/classes resolved ? */ +BOOL __objc_dangling_categories = NO; /* !T:UNUSED */ + +/* Sends +load to all classes and categories in certain + situations. */ +static void objc_send_load (void); + +/* Inserts all the classes defined in module in a tree of classes that + resembles the class hierarchy. This tree is traversed in preorder + and the classes in its nodes receive the +load message if these + methods were not executed before. The algorithm ensures that when + the +load method of a class is executed all the superclasses have + been already received the +load message. */ +static void __objc_create_classes_tree (struct objc_module *module); + +/* Calls the _objc_load_callback for each class and category in the + module (if _objc_load_callback is not NULL). */ +static void __objc_call_load_callback (struct objc_module *module); + +/* A special version that works only before the classes are completely + installed in the runtime. */ +static BOOL class_is_subclass_of_class (Class class, Class superclass); + +/* This is a node in the class tree hierarchy used to send +load + messages. */ +typedef struct objc_class_tree +{ + /* The class corresponding to the node. */ + Class class; + + /* This is a linked list of all the direct subclasses of this class. + 'head' points to a subclass node; 'tail' points to the next + objc_list node (whose 'head' points to another subclass node, + etc). */ + struct objc_list *subclasses; +} objc_class_tree; + +/* This is a linked list of objc_class_tree trees. The head of these + trees are root classes (their super class is Nil). These different + trees represent different class hierarchies. */ +static struct objc_list *__objc_class_tree_list = NULL; + +/* Keeps the +load methods who have been already executed. This hash + should not be destroyed during the execution of the program. */ +static cache_ptr __objc_load_methods = NULL; + +/* This function is used when building the class tree used to send + ordinately the +load message to all classes needing it. The tree + is really needed so that superclasses will get the message before + subclasses. + + This tree may contain classes which are being loaded (or have just + being loaded), and whose super_class pointers have not yet been + resolved. This implies that their super_class pointers point to a + string with the name of the superclass; when the first message is + sent to the class (/an object of that class) the class links will + be resolved, which will replace the super_class pointers with + pointers to the actual superclasses. + + Unfortunately, the tree might also contain classes which had been + loaded previously, and whose class links have already been + resolved. + + This function returns the superclass of a class in both cases, and + can be used to build the determine the class relationships while + building the tree. */ +static Class class_superclass_of_class (Class class) +{ + char *super_class_name; + + /* If the class links have been resolved, use the resolved + links. */ + if (CLS_ISRESOLV (class)) + return class->super_class; + + /* Else, 'class' has not yet been resolved. This means that its + super_class pointer is really the name of the super class (rather + than a pointer to the actual superclass). */ + super_class_name = (char *)class->super_class; + + /* Return Nil for a root class. */ + if (super_class_name == NULL) + return Nil; + + /* Lookup the superclass of non-root classes. */ + return objc_getClass (super_class_name); +} + + +/* Creates a tree of classes whose topmost class is directly inherited + from `upper' and the bottom class in this tree is `bottom_class'. + If `upper' is Nil, creates a class hierarchy up to a root class. + The classes in this tree are super classes of `bottom_class'. The + `subclasses' member of each tree node point to the list of + subclasses for the node. */ +static objc_class_tree * +create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper) +{ + Class superclass; + objc_class_tree *tree, *prev; + + DEBUG_PRINTF ("create_tree_of_subclasses_inherited_from:"); + DEBUG_PRINTF (" bottom_class = %s, upper = %s\n", + (bottom_class ? bottom_class->name : NULL), + (upper ? upper->name : NULL)); + + superclass = class_superclass_of_class (bottom_class); + + prev = objc_calloc (1, sizeof (objc_class_tree)); + prev->class = bottom_class; + + if (superclass == upper) + return prev; + + while (superclass != upper) + { + tree = objc_calloc (1, sizeof (objc_class_tree)); + tree->class = superclass; + tree->subclasses = list_cons (prev, tree->subclasses); + superclass = class_superclass_of_class (superclass); + prev = tree; + } + + return tree; +} + +/* Insert the `class' into the proper place in the `tree' class + hierarchy. This function returns a new tree if the class has been + successfully inserted into the tree or NULL if the class is not + part of the classes hierarchy described by `tree'. This function + is private to objc_tree_insert_class (), you should not call it + directly. */ +static objc_class_tree * +__objc_tree_insert_class (objc_class_tree *tree, Class class) +{ + DEBUG_PRINTF ("__objc_tree_insert_class: tree = %p (root: %s), class = %s\n", + tree, ((tree && tree->class) ? tree->class->name : "Nil"), class->name); + + if (tree == NULL) + return create_tree_of_subclasses_inherited_from (class, NULL); + else if (class == tree->class) + { + /* `class' has been already inserted. */ + DEBUG_PRINTF (" 1. class %s was previously inserted\n", class->name); + return tree; + } + else if (class_superclass_of_class (class) == tree->class) + { + /* If class is a direct subclass of tree->class then add class + to the list of subclasses. First check to see if it wasn't + already inserted. */ + struct objc_list *list = tree->subclasses; + objc_class_tree *node; + + while (list) + { + /* Class has been already inserted; do nothing just return + the tree. */ + if (((objc_class_tree *) list->head)->class == class) + { + DEBUG_PRINTF (" 2. class %s was previously inserted\n", + class->name); + return tree; + } + list = list->tail; + } + + /* Create a new node class and insert it into the list of + subclasses. */ + node = objc_calloc (1, sizeof (objc_class_tree)); + node->class = class; + tree->subclasses = list_cons (node, tree->subclasses); + DEBUG_PRINTF (" 3. class %s inserted\n", class->name); + return tree; + } + else + { + /* The class is not a direct subclass of tree->class. Search + for class's superclasses in the list of subclasses. */ + struct objc_list *subclasses = tree->subclasses; + + /* Precondition: the class must be a subclass of tree->class; + otherwise return NULL to indicate our caller that it must + take the next tree. */ + if (! class_is_subclass_of_class (class, tree->class)) + return NULL; + + for (; subclasses != NULL; subclasses = subclasses->tail) + { + Class aClass = ((objc_class_tree *) (subclasses->head))->class; + + if (class_is_subclass_of_class (class, aClass)) + { + /* If we found one of class's superclasses we insert the + class into its subtree and return the original tree + since nothing has been changed. */ + subclasses->head + = __objc_tree_insert_class (subclasses->head, class); + DEBUG_PRINTF (" 4. class %s inserted\n", class->name); + return tree; + } + } + + /* We haven't found a subclass of `class' in the `subclasses' + list. Create a new tree of classes whose topmost class is a + direct subclass of tree->class. */ + { + objc_class_tree *new_tree + = create_tree_of_subclasses_inherited_from (class, tree->class); + tree->subclasses = list_cons (new_tree, tree->subclasses); + DEBUG_PRINTF (" 5. class %s inserted\n", class->name); + return tree; + } + } +} + +/* This function inserts `class' in the right tree hierarchy classes. */ +static void +objc_tree_insert_class (Class class) +{ + struct objc_list *list_node; + objc_class_tree *tree; + + list_node = __objc_class_tree_list; + while (list_node) + { + /* Try to insert the class in this class hierarchy. */ + tree = __objc_tree_insert_class (list_node->head, class); + if (tree) + { + list_node->head = tree; + return; + } + else + list_node = list_node->tail; + } + + /* If the list was finished but the class hasn't been inserted, we + don't have an existing class hierarchy that can accomodate it. + Create a new one. */ + __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list); + __objc_class_tree_list->head = __objc_tree_insert_class (NULL, class); +} + +/* Traverse tree in preorder. Used to send +load. */ +static void +objc_preorder_traverse (objc_class_tree *tree, + int level, + void (*function) (objc_class_tree *, int)) +{ + struct objc_list *node; + + (*function) (tree, level); + for (node = tree->subclasses; node; node = node->tail) + objc_preorder_traverse (node->head, level + 1, function); +} + +/* Traverse tree in postorder. Used to destroy a tree. */ +static void +objc_postorder_traverse (objc_class_tree *tree, + int level, + void (*function) (objc_class_tree *, int)) +{ + struct objc_list *node; + + for (node = tree->subclasses; node; node = node->tail) + objc_postorder_traverse (node->head, level + 1, function); + (*function) (tree, level); +} + +/* Used to print a tree class hierarchy. */ +#ifdef DEBUG +static void +__objc_tree_print (objc_class_tree *tree, int level) +{ + int i; + + for (i = 0; i < level; i++) + printf (" "); + printf ("%s\n", tree->class->name); +} +#endif + +/* Walks on a linked list of methods in the reverse order and executes + all the methods corresponding to the `+load' selector. Walking in + the reverse order assures the +load of class is executed first and + then +load of categories because of the way in which categories are + added to the class methods. This function needs to be called with + the objc_runtime_mutex locked. */ +static void +__objc_send_load_using_method_list (struct objc_method_list *method_list, Class class) +{ + static SEL load_selector = 0; + int i; + + if (!method_list) + return; + + /* This needs no lock protection because we are called with the + objc_runtime_mutex locked. */ + if (!load_selector) + load_selector = sel_registerName ("load"); + + /* method_list is a linked list of method lists; since we're + executing in reverse order, we need to do the next list before we + do this one. */ + __objc_send_load_using_method_list (method_list->method_next, class); + + /* Search the method list. */ + for (i = 0; i < method_list->method_count; i++) + { + struct objc_method *mth = &method_list->method_list[i]; + + /* We are searching for +load methods that we haven't executed + yet. */ + if (mth->method_name && sel_eq (mth->method_name, load_selector) + && ! objc_hash_is_key_in_hash (__objc_load_methods, mth->method_imp)) + { + /* Add this method into the +load hash table, so we won't + execute it again next time. */ + objc_hash_add (&__objc_load_methods, + mth->method_imp, + mth->method_imp); + + /* Call +load. */ + DEBUG_PRINTF (" begin of [%s +load]\n", class->name); + (*mth->method_imp) ((id)class, mth->method_name); + DEBUG_PRINTF (" end of [%s +load]\n", class->name); + + break; + } + } +} + +/* This function needs to be called with the objc_runtime_mutex + locked. */ +static void +__objc_send_load (objc_class_tree *tree, + int level __attribute__ ((__unused__))) +{ + Class class = tree->class; + struct objc_method_list *method_list = class->class_pointer->methods; + + DEBUG_PRINTF ("+load: need to send load to class '%s'\n", class->name); + __objc_send_load_using_method_list (method_list, class); +} + +static void +__objc_destroy_class_tree_node (objc_class_tree *tree, + int level __attribute__ ((__unused__))) +{ + objc_free (tree); +} + +/* This is used to check if the relationship between two classes + before the runtime completely installs the classes. */ +static BOOL +class_is_subclass_of_class (Class class, Class superclass) +{ + for (; class != Nil;) + { + if (class == superclass) + return YES; + class = class_superclass_of_class (class); + } + + return NO; +} + +/* This list contains all the classes in the runtime system for whom + their superclasses are not yet known to the runtime. */ +static struct objc_list *unresolved_classes = 0; + +/* Extern function used to reference the Object class. */ +extern void __objc_force_linking (void); + +void +__objc_force_linking (void) +{ + extern void __objc_linking (void); + __objc_linking (); +} + +/* Run through the statics list, removing modules as soon as all its + statics have been initialized. */ +static void +objc_init_statics (void) +{ + struct objc_list **cell = &uninitialized_statics; + struct objc_static_instances **statics_in_module; + + objc_mutex_lock (__objc_runtime_mutex); + + while (*cell) + { + int module_initialized = 1; + + for (statics_in_module = (*cell)->head; + *statics_in_module; statics_in_module++) + { + struct objc_static_instances *statics = *statics_in_module; + Class class = objc_getClass (statics->class_name); + + if (! class) + { + /* It is unfortunate that this will cause all the + statics initialization to be done again (eg, if we + already initialized constant strings, and are now + initializing protocols, setting module_initialized to + 0 would cause constant strings to be initialized + again). It would be good to be able to track if we + have already initialized some of them. */ + module_initialized = 0; + } + else + { + /* Note that if this is a list of Protocol objects, some + of them may have been initialized already (because + they were attached to classes or categories, and the + class/category loading code automatically fixes them + up), and some of them may not. We really need to go + through the whole list to be sure! Protocols are + also special because we want to register them and + register all their selectors. */ + id *inst; + + if (strcmp (statics->class_name, "Protocol") == 0) + { + /* Protocols are special, because not only we want + to fix up their class pointers, but we also want + to register them and their selectors with the + runtime. */ + for (inst = &statics->instances[0]; *inst; inst++) + __objc_init_protocol ((struct objc_protocol *)*inst); + } + else + { + /* Other static instances (typically constant + strings) are easier as we just fix up their class + pointers. */ + for (inst = &statics->instances[0]; *inst; inst++) + (*inst)->class_pointer = class; + } + } + } + if (module_initialized) + { + /* Remove this module from the uninitialized list. */ + struct objc_list *this = *cell; + *cell = this->tail; + objc_free (this); + } + else + cell = &(*cell)->tail; + } + + objc_mutex_unlock (__objc_runtime_mutex); +} + +/* This function is called by constructor functions generated for each + module compiled. (_GLOBAL_$I$...) The purpose of this function is + to gather the module pointers so that they may be processed by the + initialization routines as soon as possible. */ +void +__objc_exec_class (struct objc_module *module) +{ + /* Have we processed any constructors previously? This flag is used + to indicate that some global data structures need to be + built. */ + static BOOL previous_constructors = 0; + + static struct objc_list *unclaimed_categories = 0; + + /* The symbol table (defined in objc-private/module-abi-8.h) + generated by gcc. */ + struct objc_symtab *symtab = module->symtab; + + /* The statics in this module. */ + struct objc_static_instances **statics + = symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt]; + + /* Entry used to traverse hash lists. */ + struct objc_list **cell; + + /* The table of selector references for this module. */ + struct objc_selector *selectors = symtab->refs; + + int i; + + DEBUG_PRINTF ("\n__objc_exec_class (%p) - start processing module...\n", module); + + /* Check gcc version. */ + init_check_module_version (module); + + /* On the first call of this routine, initialize some data + structures. */ + if (! previous_constructors) + { + /* Initialize thread-safe system. */ + __objc_init_thread_system (); + __objc_runtime_threads_alive = 1; + __objc_runtime_mutex = objc_mutex_allocate (); + + __objc_init_selector_tables (); + __objc_init_class_tables (); + __objc_init_dispatch_tables (); + duplicate_classes = objc_hash_new (8, + (hash_func_type)objc_hash_ptr, + objc_compare_ptrs); + __objc_load_methods = objc_hash_new (128, + (hash_func_type)objc_hash_ptr, + objc_compare_ptrs); + __objc_protocols_init (); + __objc_accessors_init (); + __objc_sync_init (); + previous_constructors = 1; + } + + /* Save the module pointer so that later we remember to call +load + on all classes and categories on it. */ + objc_mutex_lock (__objc_runtime_mutex); + __objc_module_list = list_cons (module, __objc_module_list); + + /* Replace referenced selectors from names to SELs. */ + if (selectors) + { + DEBUG_PRINTF (" registering selectors\n"); + __objc_register_selectors_from_module (selectors); + } + + /* Parse the classes in the load module and gather selector + information. */ + for (i = 0; i < symtab->cls_def_cnt; ++i) + { + Class class = (Class) symtab->defs[i]; + const char *superclass = (char *) class->super_class; + + /* Make sure we have what we think. */ + assert (CLS_ISCLASS (class)); + assert (CLS_ISMETA (class->class_pointer)); + DEBUG_PRINTF (" installing class '%s'\n", class->name); + + /* Workaround for a bug in clang: Clang may set flags other than + _CLS_CLASS and _CLS_META even when compiling for the + traditional ABI (version 8), confusing our runtime. Try to + wipe these flags out. */ + if (CLS_ISCLASS (class)) + __CLS_INFO (class) = _CLS_CLASS; + else + __CLS_INFO (class) = _CLS_META; + + /* Initialize the subclass list to be NULL. In some cases it + isn't and this crashes the program. */ + class->subclass_list = NULL; + + if (__objc_init_class (class)) + { + /* Check to see if the superclass is known in this point. If + it's not add the class to the unresolved_classes list. */ + if (superclass && ! objc_getClass (superclass)) + unresolved_classes = list_cons (class, unresolved_classes); + } + } + + /* Process category information from the module. */ + for (i = 0; i < symtab->cat_def_cnt; ++i) + { + struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt]; + Class class = objc_getClass (category->class_name); + + /* If the class for the category exists then append its + methods. */ + if (class) + { + DEBUG_PRINTF (" installing category '%s (%s)'\n", category->class_name, category->category_name); + /* Do instance methods. */ + if (category->instance_methods) + class_add_method_list (class, category->instance_methods); + + /* Do class methods. */ + if (category->class_methods) + class_add_method_list ((Class) class->class_pointer, + category->class_methods); + + if (category->protocols) + { + __objc_init_protocols (category->protocols); + __objc_class_add_protocols (class, category->protocols); + } + + /* Register the instance methods as class methods, this is + only done for root classes. */ + __objc_register_instance_methods_to_class (class); + } + else + { + DEBUG_PRINTF (" delaying installation of category '%s (%s)'\n", category->class_name, category->category_name); + /* The object to which the category methods belong can't be + found. Save the information. */ + unclaimed_categories = list_cons (category, unclaimed_categories); + } + } + + if (statics) + uninitialized_statics = list_cons (statics, uninitialized_statics); + if (uninitialized_statics) + objc_init_statics (); + + /* Scan the unclaimed category hash. Attempt to attach any + unclaimed categories to objects. */ + for (cell = &unclaimed_categories; *cell; ) + { + struct objc_category *category = (*cell)->head; + Class class = objc_getClass (category->class_name); + + if (class) + { + DEBUG_PRINTF (" installing (delayed) category '%s (%s)'\n", category->class_name, category->category_name); + list_remove_head (cell); + + if (category->instance_methods) + class_add_method_list (class, category->instance_methods); + + if (category->class_methods) + class_add_method_list ((Class) class->class_pointer, + category->class_methods); + + if (category->protocols) + { + __objc_init_protocols (category->protocols); + __objc_class_add_protocols (class, category->protocols); + } + + /* Register the instance methods as class methods, this is + only done for root classes. */ + __objc_register_instance_methods_to_class (class); + } + else + cell = &(*cell)->tail; + } + + if (unclaimed_proto_list && objc_getClass ("Protocol")) + { + list_mapcar (unclaimed_proto_list, + (void (*) (void *))__objc_init_protocols); + list_free (unclaimed_proto_list); + unclaimed_proto_list = 0; + } + + objc_send_load (); + + /* Check if there are no unresolved classes (ie, classes whose + superclass has not been loaded yet) and that the 'Object' class, + used as the class of classes, exist. If so, it is worth + "resolving the class links" at this point, which will setup all + the class/superclass pointers. */ + if (!unresolved_classes && objc_getClass ("Object")) + { + DEBUG_PRINTF (" resolving class links\n"); + __objc_resolve_class_links (); + } + + objc_mutex_unlock (__objc_runtime_mutex); + + DEBUG_PRINTF ("__objc_exec_class (%p) - finished processing module...\n\n", module); +} + +/* This function needs to be called with the objc_runtime_mutex + locked. */ +static void +objc_send_load (void) +{ + if (!__objc_module_list) + return; + + /* Try to find out if all the classes loaded so far also have their + superclasses known to the runtime. We suppose that the objects + that are allocated in the +load method are in general of a class + declared in the same module. */ + if (unresolved_classes) + { + Class class = unresolved_classes->head; + + while (objc_getClass ((char *) class->super_class)) + { + list_remove_head (&unresolved_classes); + if (unresolved_classes) + class = unresolved_classes->head; + else + break; + } + + /* If we still have classes for whom we don't have yet their + super classes known to the runtime we don't send the +load + messages (and call the load callback) yet. */ + if (unresolved_classes) + return; + } + + /* Special check. If 'Object', which is used by meta-classes, has + not been loaded yet, delay sending of +load. */ + if (! objc_getClass ("Object")) + return; + + /* Iterate over all modules in the __objc_module_list and call on + them the __objc_create_classes_tree function. This function + creates a tree of classes that resembles the class hierarchy. */ + list_mapcar (__objc_module_list, + (void (*) (void *)) __objc_create_classes_tree); + + while (__objc_class_tree_list) + { +#ifdef DEBUG + objc_preorder_traverse (__objc_class_tree_list->head, + 0, __objc_tree_print); +#endif + objc_preorder_traverse (__objc_class_tree_list->head, + 0, __objc_send_load); + objc_postorder_traverse (__objc_class_tree_list->head, + 0, __objc_destroy_class_tree_node); + list_remove_head (&__objc_class_tree_list); + } + + /* For each module, call the _objc_load_callback if any is + defined. */ + list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_load_callback); + + /* Empty the list of modules. */ + list_free (__objc_module_list); + __objc_module_list = NULL; +} + +static void +__objc_create_classes_tree (struct objc_module *module) +{ + /* The runtime mutex is locked at this point */ + struct objc_symtab *symtab = module->symtab; + int i; + + /* Iterate thru classes defined in this module and insert them in + the classes tree hierarchy. */ + for (i = 0; i < symtab->cls_def_cnt; i++) + { + Class class = (Class) symtab->defs[i]; + + if (!objc_hash_is_key_in_hash (duplicate_classes, class)) + objc_tree_insert_class (class); + } + + /* Now iterate over "claimed" categories too (ie, categories that + extend a class that has already been loaded by the runtime), and + insert them in the classes tree hiearchy too. Otherwise, if you + add a category, its +load method would not be called if the class + is already loaded in the runtime. It the category is + "unclaimed", ie, we haven't loaded the main class yet, postpone + sending +load as we want to execute +load from the class before + we execute the one from the category. */ + for (i = 0; i < symtab->cat_def_cnt; ++i) + { + struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt]; + Class class = objc_getClass (category->class_name); + + /* If the class for the category exists then append its + methods. */ + if (class) + objc_tree_insert_class (class); + } +} + +static void +__objc_call_load_callback (struct objc_module *module) +{ + if (_objc_load_callback) + { + /* The runtime mutex is locked at this point. */ + struct objc_symtab *symtab = module->symtab; + int i; + + /* Iterate thru classes defined in this module and call the callback + for each one. */ + for (i = 0; i < symtab->cls_def_cnt; i++) + { + Class class = (Class) symtab->defs[i]; + + if (!objc_hash_is_key_in_hash (duplicate_classes, class)) + { + /* Call the _objc_load_callback for this class. */ + DEBUG_PRINTF (" calling the load callback for class '%s'\n", class->name); + _objc_load_callback (class, 0); + } + } + + /* Call the _objc_load_callback for categories. Don't register + the instance methods as class methods for categories to root + classes since they were already added in the class. */ + for (i = 0; i < symtab->cat_def_cnt; i++) + { + struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt]; + Class class = objc_getClass (category->class_name); + + DEBUG_PRINTF (" calling the load callback for category '%s (%s)'\n", + category->class_name, category->category_name); + _objc_load_callback (class, category); + } + } +} + +/* Sanity check the version of gcc used to compile `module'. */ +static void +init_check_module_version (struct objc_module *module) +{ + if ((module->version != OBJC_VERSION) || (module->size != sizeof (struct objc_module))) + { + _objc_abort ("Module %s version %d doesn't match runtime %d\n", + module->name, (int)module->version, OBJC_VERSION); + } +} + +/* __objc_init_class must be called with __objc_runtime_mutex already + locked. Return YES if the class could be setup; return NO if the + class could not be setup because a class with the same name already + exists. */ +BOOL +__objc_init_class (Class class) +{ + /* Store the class in the class table and assign class numbers. */ + if (__objc_add_class_to_hash (class)) + { + /* Register all of the selectors in the class and meta class. */ + __objc_register_selectors_from_class (class); + __objc_register_selectors_from_class ((Class) class->class_pointer); + + /* Install the fake dispatch tables. */ + __objc_install_premature_dtable (class); + __objc_install_premature_dtable (class->class_pointer); + + /* Register the instance methods as class methods, this is only + done for root classes. */ + __objc_register_instance_methods_to_class (class); + + if (class->protocols) + __objc_init_protocols (class->protocols); + + return YES; + } + else + { + /* The module contains a duplicate class. Remember it so that + we will ignore it later. */ + DEBUG_PRINTF (" duplicate class '%s' - will be ignored\n", class->name); + objc_hash_add (&duplicate_classes, class, class); + return NO; + } +} + +/* __objc_init_protocol must be called with __objc_runtime_mutex + already locked, and the "Protocol" class already registered. */ +static void +__objc_init_protocol (struct objc_protocol *protocol) +{ + static Class proto_class = 0; + + if (! proto_class) + proto_class = objc_getClass ("Protocol"); + + if (((size_t)protocol->class_pointer) == PROTOCOL_VERSION) + { + /* Assign class pointer. */ + protocol->class_pointer = proto_class; + + /* Register all the selectors in the protocol with the runtime. + This both registers the selectors with the right types, and + it also fixes up the 'struct objc_method' structures inside + the protocol so that each method_name (a char * as compiled + by the compiler) is replaced with the appropriate runtime + SEL. */ + if (protocol->class_methods) + __objc_register_selectors_from_description_list (protocol->class_methods); + + if (protocol->instance_methods) + __objc_register_selectors_from_description_list (protocol->instance_methods); + + /* Register the protocol in the hashtable or protocols by + name. */ + __objc_protocols_add_protocol (protocol->protocol_name, protocol); + + /* Init super protocols. */ + __objc_init_protocols (protocol->protocol_list); + } + else if (protocol->class_pointer != proto_class) + { + _objc_abort ("Version %d doesn't match runtime protocol version %d\n", + (int) ((char *) protocol->class_pointer + - (char *) 0), + PROTOCOL_VERSION); + } +} + +static void +__objc_init_protocols (struct objc_protocol_list *protos) +{ + size_t i; + static Class proto_class = 0; + + if (! protos) + return; + + objc_mutex_lock (__objc_runtime_mutex); + + if (! proto_class) + proto_class = objc_getClass ("Protocol"); + + if (! proto_class) + { + unclaimed_proto_list = list_cons (protos, unclaimed_proto_list); + objc_mutex_unlock (__objc_runtime_mutex); + return; + } + +#if 0 + assert (protos->next == 0); /* Only single ones allowed. */ +#endif + + for (i = 0; i < protos->count; i++) + { + struct objc_protocol *aProto = protos->list[i]; + __objc_init_protocol (aProto); + } + + objc_mutex_unlock (__objc_runtime_mutex); +} + +static void +__objc_class_add_protocols (Class class, struct objc_protocol_list *protos) +{ + if (! protos) + return; + + protos->next = class->protocols; + class->protocols = protos; +} |