1 /* GNU Objective C Runtime initialization
2 Copyright (C) 1993, 1995, 1996, 1997, 2002, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Kresten Krab Thorup
5 +load support contributed by Ovidiu Predescu <ovidiu@net-community.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under the
10 terms of the GNU General Public License as published by the Free Software
11 Foundation; either version 3, or (at your option) any later version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
18 Under Section 7 of GPL version 3, you are granted additional
19 permissions described in the GCC Runtime Library Exception, version
20 3.1, as published by the Free Software Foundation.
22 You should have received a copy of the GNU General Public License and
23 a copy of the GCC Runtime Library Exception along with this program;
24 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 <http://www.gnu.org/licenses/>. */
27 /* Uncommented the following line to enable debug logging. Use this
28 only while debugging the runtime. */
31 #include "objc-private/common.h"
32 #include "objc-private/error.h"
33 #include "objc/runtime.h"
35 #include "objc-private/hash.h"
36 #include "objc-private/objc-list.h"
37 #include "objc-private/module-abi-8.h"
38 #include "objc-private/runtime.h" /* For __objc_resolve_class_links(). */
39 #include "objc-private/selector.h" /* For __sel_register_typed_name(). */
40 #include "objc-private/objc-sync.h" /* For __objc_sync_init() */
41 #include "objc-private/protocols.h" /* For __objc_protocols_init(),
42 __objc_protocols_add_protocol()
43 __objc_protocols_register_selectors() */
44 #include "objc-private/accessors.h" /* For __objc_accessors_init() */
46 /* The version number of this runtime. This must match the number
47 defined in gcc (objc-act.c). */
48 #define OBJC_VERSION 8
49 #define PROTOCOL_VERSION 2
51 /* This list contains modules currently loaded into the runtime and
52 for which the +load method (and the load callback, if any) has not
54 static struct objc_list *__objc_module_list = 0; /* !T:MUTEX */
56 /* This list contains all proto_list's not yet assigned class
58 static struct objc_list *unclaimed_proto_list = 0; /* !T:MUTEX */
60 /* List of unresolved static instances. */
61 static struct objc_list *uninitialized_statics = 0; /* !T:MUTEX */
63 /* List of duplicated classes found while loading modules. If we find
64 a class twice, we ignore it the second time. On some platforms,
65 where the order in which modules are loaded is well defined, this
66 allows you to replace a class in a shared library by linking in a
67 new implementation which is loaded in in the right order, and which
68 overrides the existing one.
70 Protected by __objc_runtime_mutex. */
71 static cache_ptr duplicate_classes = NULL;
73 /* Global runtime "write" mutex. Having a single mutex prevents
74 deadlocks, but reduces concurrency. To improve concurrency, some
75 groups of functions in the runtime have their own separate mutex
76 (eg, __class_table_lock in class.c); to avoid deadlocks, these
77 routines must make sure that they never acquire any other lock
78 while holding their own local lock. Ie, they should lock, execute
79 some C code that does not perform any calls to other runtime
80 functions which may potentially lock different locks, then unlock.
81 If they need to perform any calls to other runtime functions that
82 may potentially lock other locks, then they should use the global
83 __objc_runtime_mutex. */
84 objc_mutex_t __objc_runtime_mutex = 0;
86 /* Number of threads that are alive. */
87 int __objc_runtime_threads_alive = 1; /* !T:MUTEX */
89 /* Check compiler vs runtime version. */
90 static void init_check_module_version (struct objc_module *);
92 /* Assign isa links to protos. */
93 static void __objc_init_protocols (struct objc_protocol_list *protos);
95 /* Assign isa link to a protocol, and register it. */
96 static void __objc_init_protocol (struct objc_protocol *protocol);
98 /* Add protocol to class. */
99 static void __objc_class_add_protocols (Class, struct objc_protocol_list *);
101 /* Load callback hook. */
102 void (*_objc_load_callback) (Class class, struct objc_category *category) = 0; /* !T:SAFE */
104 /* Are all categories/classes resolved ? */
105 BOOL __objc_dangling_categories = NO; /* !T:UNUSED */
107 /* Sends +load to all classes and categories in certain
109 static void objc_send_load (void);
111 /* Inserts all the classes defined in module in a tree of classes that
112 resembles the class hierarchy. This tree is traversed in preorder
113 and the classes in its nodes receive the +load message if these
114 methods were not executed before. The algorithm ensures that when
115 the +load method of a class is executed all the superclasses have
116 been already received the +load message. */
117 static void __objc_create_classes_tree (struct objc_module *module);
119 /* Calls the _objc_load_callback for each class and category in the
120 module (if _objc_load_callback is not NULL). */
121 static void __objc_call_load_callback (struct objc_module *module);
123 /* A special version that works only before the classes are completely
124 installed in the runtime. */
125 static BOOL class_is_subclass_of_class (Class class, Class superclass);
127 typedef struct objc_class_tree
130 struct objc_list *subclasses; /* `head' is a pointer to an
134 /* This is a linked list of objc_class_tree trees. The head of these
135 trees are root classes (their super class is Nil). These different
136 trees represent different class hierarchies. */
137 static struct objc_list *__objc_class_tree_list = NULL;
139 /* Keeps the +load methods who have been already executed. This hash
140 should not be destroyed during the execution of the program. */
141 static cache_ptr __objc_load_methods = NULL;
143 /* This function is used when building the class tree used to send
144 ordinately the +load message to all classes needing it. The tree
145 is really needed so that superclasses will get the message before
148 This tree will contain classes which are being loaded (or have just
149 being loaded), and whose super_class pointers have not yet been
150 resolved. This implies that their super_class pointers point to a
151 string with the name of the superclass; when the first message is
152 sent to the class (/an object of that class) the class links will
153 be resolved, which will replace the super_class pointers with
154 pointers to the actual superclasses.
156 Unfortunately, the tree might also contain classes which had been
157 loaded previously, and whose class links have already been
160 This function returns the superclass of a class in both cases, and
161 can be used to build the determine the class relationships while
162 building the tree. */
163 static Class class_superclass_of_class (Class class)
165 char *super_class_name;
167 /* If the class links have been resolved, use the resolved
169 if (CLS_ISRESOLV (class))
170 return class->super_class;
172 /* Else, 'class' has not yet been resolved. This means that its
173 super_class pointer is really the name of the super class (rather
174 than a pointer to the actual superclass). */
175 super_class_name = (char *)class->super_class;
177 /* Return Nil for a root class. */
178 if (super_class_name == NULL)
181 /* Lookup the superclass of non-root classes. */
182 return objc_getClass (super_class_name);
186 /* Creates a tree of classes whose topmost class is directly inherited
187 from `upper' and the bottom class in this tree is
188 `bottom_class'. The classes in this tree are super classes of
189 `bottom_class'. `subclasses' member of each tree node point to the
190 next subclass tree node. */
191 static objc_class_tree *
192 create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper)
195 objc_class_tree *tree, *prev;
197 if (bottom_class->super_class)
198 superclass = objc_getClass ((char *) bottom_class->super_class);
202 DEBUG_PRINTF ("create_tree_of_subclasses_inherited_from:");
203 DEBUG_PRINTF (" bottom_class = %s, upper = %s\n",
204 (bottom_class ? bottom_class->name : NULL),
205 (upper ? upper->name : NULL));
207 tree = prev = objc_calloc (1, sizeof (objc_class_tree));
208 prev->class = bottom_class;
210 while (superclass != upper)
212 tree = objc_calloc (1, sizeof (objc_class_tree));
213 tree->class = superclass;
214 tree->subclasses = list_cons (prev, tree->subclasses);
215 superclass = class_superclass_of_class (superclass);
222 /* Insert the `class' into the proper place in the `tree' class
223 hierarchy. This function returns a new tree if the class has been
224 successfully inserted into the tree or NULL if the class is not
225 part of the classes hierarchy described by `tree'. This function is
226 private to objc_tree_insert_class (), you should not call it
228 static objc_class_tree *
229 __objc_tree_insert_class (objc_class_tree *tree, Class class)
231 DEBUG_PRINTF ("__objc_tree_insert_class: tree = %p, class = %s\n",
235 return create_tree_of_subclasses_inherited_from (class, NULL);
236 else if (class == tree->class)
238 /* `class' has been already inserted. */
239 DEBUG_PRINTF (" 1. class %s was previously inserted\n", class->name);
242 else if (class_superclass_of_class (class) == tree->class)
244 /* If class is a direct subclass of tree->class then add class
245 to the list of subclasses. First check to see if it wasn't
247 struct objc_list *list = tree->subclasses;
248 objc_class_tree *node;
252 /* Class has been already inserted; do nothing just return
254 if (((objc_class_tree *) list->head)->class == class)
256 DEBUG_PRINTF (" 2. class %s was previously inserted\n",
263 /* Create a new node class and insert it into the list of
265 node = objc_calloc (1, sizeof (objc_class_tree));
267 tree->subclasses = list_cons (node, tree->subclasses);
268 DEBUG_PRINTF (" 3. class %s inserted\n", class->name);
273 /* The class is not a direct subclass of tree->class. Search
274 for class's superclasses in the list of subclasses. */
275 struct objc_list *subclasses = tree->subclasses;
277 /* Precondition: the class must be a subclass of tree->class;
278 otherwise return NULL to indicate our caller that it must
279 take the next tree. */
280 if (! class_is_subclass_of_class (class, tree->class))
283 for (; subclasses != NULL; subclasses = subclasses->tail)
285 Class aClass = ((objc_class_tree *) (subclasses->head))->class;
287 if (class_is_subclass_of_class (class, aClass))
289 /* If we found one of class's superclasses we insert the
290 class into its subtree and return the original tree
291 since nothing has been changed. */
293 = __objc_tree_insert_class (subclasses->head, class);
294 DEBUG_PRINTF (" 4. class %s inserted\n", class->name);
299 /* We haven't found a subclass of `class' in the `subclasses'
300 list. Create a new tree of classes whose topmost class is a
301 direct subclass of tree->class. */
303 objc_class_tree *new_tree
304 = create_tree_of_subclasses_inherited_from (class, tree->class);
305 tree->subclasses = list_cons (new_tree, tree->subclasses);
306 DEBUG_PRINTF (" 5. class %s inserted\n", class->name);
312 /* This function inserts `class' in the right tree hierarchy classes. */
314 objc_tree_insert_class (Class class)
316 struct objc_list *list_node;
317 objc_class_tree *tree;
319 list_node = __objc_class_tree_list;
322 tree = __objc_tree_insert_class (list_node->head, class);
325 list_node->head = tree;
329 list_node = list_node->tail;
332 /* If the list was finished but the class hasn't been inserted,
336 __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
337 __objc_class_tree_list->head = __objc_tree_insert_class (NULL, class);
341 /* Traverse tree in preorder. Used to send +load. */
343 objc_preorder_traverse (objc_class_tree *tree,
345 void (*function) (objc_class_tree *, int))
347 struct objc_list *node;
349 (*function) (tree, level);
350 for (node = tree->subclasses; node; node = node->tail)
351 objc_preorder_traverse (node->head, level + 1, function);
354 /* Traverse tree in postorder. Used to destroy a tree. */
356 objc_postorder_traverse (objc_class_tree *tree,
358 void (*function) (objc_class_tree *, int))
360 struct objc_list *node;
362 for (node = tree->subclasses; node; node = node->tail)
363 objc_postorder_traverse (node->head, level + 1, function);
364 (*function) (tree, level);
367 /* Used to print a tree class hierarchy. */
370 __objc_tree_print (objc_class_tree *tree, int level)
374 for (i = 0; i < level; i++)
376 printf ("%s\n", tree->class->name);
380 /* Walks on a linked list of methods in the reverse order and executes
381 all the methods corresponding to the `+load' selector. Walking in
382 the reverse order assures the +load of class is executed first and
383 then +load of categories because of the way in which categories are
384 added to the class methods. This function needs to be called with
385 the objc_runtime_mutex locked. */
387 __objc_send_load_using_method_list (struct objc_method_list *method_list, Class class)
389 static SEL load_selector = 0;
395 /* This needs no lock protection because we are called with the
396 objc_runtime_mutex locked. */
398 load_selector = sel_registerName ("load");
400 /* method_list is a linked list of method lists; since we're
401 executing in reverse order, we need to do the next list before we
403 __objc_send_load_using_method_list (method_list->method_next, class);
405 /* Search the method list. */
406 for (i = 0; i < method_list->method_count; i++)
408 struct objc_method *mth = &method_list->method_list[i];
410 /* We are searching for +load methods that we haven't executed
412 if (mth->method_name && sel_eq (mth->method_name, load_selector)
413 && ! objc_hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
415 /* Add this method into the +load hash table, so we won't
416 execute it again next time. */
417 objc_hash_add (&__objc_load_methods,
422 DEBUG_PRINTF (" begin of [%s +load]\n", class->name);
423 (*mth->method_imp) ((id)class, mth->method_name);
424 DEBUG_PRINTF (" end of [%s +load]\n", class->name);
431 /* This function needs to be called with the objc_runtime_mutex
434 __objc_send_load (objc_class_tree *tree,
435 int level __attribute__ ((__unused__)))
437 Class class = tree->class;
438 struct objc_method_list *method_list = class->class_pointer->methods;
440 DEBUG_PRINTF ("+load: need to send load to class '%s'\n", class->name);
441 __objc_send_load_using_method_list (method_list, class);
445 __objc_destroy_class_tree_node (objc_class_tree *tree,
446 int level __attribute__ ((__unused__)))
451 /* This is used to check if the relationship between two classes
452 before the runtime completely installs the classes. */
454 class_is_subclass_of_class (Class class, Class superclass)
456 for (; class != Nil;)
458 if (class == superclass)
460 class = class_superclass_of_class (class);
466 /* This list contains all the classes in the runtime system for whom
467 their superclasses are not yet known to the runtime. */
468 static struct objc_list *unresolved_classes = 0;
470 /* Extern function used to reference the Object class. */
471 extern void __objc_force_linking (void);
474 __objc_force_linking (void)
476 extern void __objc_linking (void);
480 /* Run through the statics list, removing modules as soon as all its
481 statics have been initialized. */
483 objc_init_statics (void)
485 struct objc_list **cell = &uninitialized_statics;
486 struct objc_static_instances **statics_in_module;
488 objc_mutex_lock (__objc_runtime_mutex);
492 int module_initialized = 1;
494 for (statics_in_module = (*cell)->head;
495 *statics_in_module; statics_in_module++)
497 struct objc_static_instances *statics = *statics_in_module;
498 Class class = objc_getClass (statics->class_name);
502 /* It is unfortunate that this will cause all the
503 statics initialization to be done again (eg, if we
504 already initialized constant strings, and are now
505 initializing protocols, setting module_initialized to
506 0 would cause constant strings to be initialized
507 again). It would be good to be able to track if we
508 have already initialized some of them. */
509 module_initialized = 0;
513 /* Note that if this is a list of Protocol objects, some
514 of them may have been initialized already (because
515 they were attached to classes or categories, and the
516 class/category loading code automatically fixes them
517 up), and some of them may not. We really need to go
518 through the whole list to be sure! Protocols are
519 also special because we want to register them and
520 register all their selectors. */
523 if (strcmp (statics->class_name, "Protocol") == 0)
525 /* Protocols are special, because not only we want
526 to fix up their class pointers, but we also want
527 to register them and their selectors with the
529 for (inst = &statics->instances[0]; *inst; inst++)
530 __objc_init_protocol ((struct objc_protocol *)*inst);
534 /* Other static instances (typically constant
535 strings) are easier as we just fix up their class
537 for (inst = &statics->instances[0]; *inst; inst++)
538 (*inst)->class_pointer = class;
542 if (module_initialized)
544 /* Remove this module from the uninitialized list. */
545 struct objc_list *this = *cell;
550 cell = &(*cell)->tail;
553 objc_mutex_unlock (__objc_runtime_mutex);
556 /* This function is called by constructor functions generated for each
557 module compiled. (_GLOBAL_$I$...) The purpose of this function is
558 to gather the module pointers so that they may be processed by the
559 initialization routines as soon as possible. */
561 __objc_exec_class (struct objc_module *module)
563 /* Have we processed any constructors previously? This flag is used
564 to indicate that some global data structures need to be
566 static BOOL previous_constructors = 0;
568 static struct objc_list *unclaimed_categories = 0;
570 /* The symbol table (defined in objc-private/module-abi-8.h)
572 struct objc_symtab *symtab = module->symtab;
574 /* The statics in this module. */
575 struct objc_static_instances **statics
576 = symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt];
578 /* Entry used to traverse hash lists. */
579 struct objc_list **cell;
581 /* The table of selector references for this module. */
582 struct objc_selector *selectors = symtab->refs;
586 DEBUG_PRINTF ("\n__objc_exec_class (%p) - start processing module...\n", module);
588 /* Check gcc version. */
589 init_check_module_version (module);
591 /* On the first call of this routine, initialize some data
593 if (! previous_constructors)
595 /* Initialize thread-safe system. */
596 __objc_init_thread_system ();
597 __objc_runtime_threads_alive = 1;
598 __objc_runtime_mutex = objc_mutex_allocate ();
600 __objc_init_selector_tables ();
601 __objc_init_class_tables ();
602 __objc_init_dispatch_tables ();
603 duplicate_classes = objc_hash_new (8,
604 (hash_func_type)objc_hash_ptr,
606 __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
607 __objc_load_methods = objc_hash_new (128,
608 (hash_func_type)objc_hash_ptr,
610 __objc_protocols_init ();
611 __objc_accessors_init ();
613 previous_constructors = 1;
616 /* Save the module pointer so that later we remember to call +load
617 on all classes and categories on it. */
618 objc_mutex_lock (__objc_runtime_mutex);
619 __objc_module_list = list_cons (module, __objc_module_list);
621 /* Replace referenced selectors from names to SELs. */
624 DEBUG_PRINTF (" registering selectors\n");
625 __objc_register_selectors_from_module (selectors);
628 /* Parse the classes in the load module and gather selector
630 for (i = 0; i < symtab->cls_def_cnt; ++i)
632 Class class = (Class) symtab->defs[i];
633 const char *superclass = (char *) class->super_class;
635 /* Make sure we have what we think. */
636 assert (CLS_ISCLASS (class));
637 assert (CLS_ISMETA (class->class_pointer));
638 DEBUG_PRINTF (" installing class '%s'\n", class->name);
640 /* Initialize the subclass list to be NULL. In some cases it
641 isn't and this crashes the program. */
642 class->subclass_list = NULL;
644 if (__objc_init_class (class))
646 /* Check to see if the superclass is known in this point. If
647 it's not add the class to the unresolved_classes list. */
648 if (superclass && ! objc_getClass (superclass))
649 unresolved_classes = list_cons (class, unresolved_classes);
653 /* Process category information from the module. */
654 for (i = 0; i < symtab->cat_def_cnt; ++i)
656 struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
657 Class class = objc_getClass (category->class_name);
659 /* If the class for the category exists then append its
663 DEBUG_PRINTF (" installing category '%s (%s)'\n", category->class_name, category->category_name);
664 /* Do instance methods. */
665 if (category->instance_methods)
666 class_add_method_list (class, category->instance_methods);
668 /* Do class methods. */
669 if (category->class_methods)
670 class_add_method_list ((Class) class->class_pointer,
671 category->class_methods);
673 if (category->protocols)
675 __objc_init_protocols (category->protocols);
676 __objc_class_add_protocols (class, category->protocols);
679 /* Register the instance methods as class methods, this is
680 only done for root classes. */
681 __objc_register_instance_methods_to_class (class);
685 DEBUG_PRINTF (" delaying installation of category '%s (%s)'\n", category->class_name, category->category_name);
686 /* The object to which the category methods belong can't be
687 found. Save the information. */
688 unclaimed_categories = list_cons (category, unclaimed_categories);
693 uninitialized_statics = list_cons (statics, uninitialized_statics);
694 if (uninitialized_statics)
695 objc_init_statics ();
697 /* Scan the unclaimed category hash. Attempt to attach any
698 unclaimed categories to objects. */
699 for (cell = &unclaimed_categories; *cell; )
701 struct objc_category *category = (*cell)->head;
702 Class class = objc_getClass (category->class_name);
706 DEBUG_PRINTF (" installing (delayed) category '%s (%s)'\n", category->class_name, category->category_name);
707 list_remove_head (cell);
709 if (category->instance_methods)
710 class_add_method_list (class, category->instance_methods);
712 if (category->class_methods)
713 class_add_method_list ((Class) class->class_pointer,
714 category->class_methods);
716 if (category->protocols)
718 __objc_init_protocols (category->protocols);
719 __objc_class_add_protocols (class, category->protocols);
722 /* Register the instance methods as class methods, this is
723 only done for root classes. */
724 __objc_register_instance_methods_to_class (class);
727 cell = &(*cell)->tail;
730 if (unclaimed_proto_list && objc_getClass ("Protocol"))
732 list_mapcar (unclaimed_proto_list,
733 (void (*) (void *))__objc_init_protocols);
734 list_free (unclaimed_proto_list);
735 unclaimed_proto_list = 0;
740 /* Check if there are no unresolved classes (ie, classes whose
741 superclass has not been loaded yet) and that the 'Object' class,
742 used as the class of classes, exist. If so, it is worth
743 "resolving the class links" at this point, which will setup all
744 the class/superclass pointers. */
745 if (!unresolved_classes && objc_getClass ("Object"))
747 DEBUG_PRINTF (" resolving class links\n");
748 __objc_resolve_class_links ();
751 objc_mutex_unlock (__objc_runtime_mutex);
753 DEBUG_PRINTF ("__objc_exec_class (%p) - finished processing module...\n\n", module);
756 /* This function needs to be called with the objc_runtime_mutex
759 objc_send_load (void)
761 if (!__objc_module_list)
764 /* Try to find out if all the classes loaded so far also have their
765 superclasses known to the runtime. We suppose that the objects
766 that are allocated in the +load method are in general of a class
767 declared in the same module. */
768 if (unresolved_classes)
770 Class class = unresolved_classes->head;
772 while (objc_getClass ((char *) class->super_class))
774 list_remove_head (&unresolved_classes);
775 if (unresolved_classes)
776 class = unresolved_classes->head;
781 /* If we still have classes for whom we don't have yet their
782 super classes known to the runtime we don't send the +load
783 messages (and call the load callback) yet. */
784 if (unresolved_classes)
788 /* Special check. If 'Object', which is used by meta-classes, has
789 not been loaded yet, delay sending of +load. */
790 if (! objc_getClass ("Object"))
793 /* Iterate over all modules in the __objc_module_list and call on
794 them the __objc_create_classes_tree function. This function
795 creates a tree of classes that resembles the class hierarchy. */
796 list_mapcar (__objc_module_list,
797 (void (*) (void *)) __objc_create_classes_tree);
799 while (__objc_class_tree_list)
802 objc_preorder_traverse (__objc_class_tree_list->head,
803 0, __objc_tree_print);
805 objc_preorder_traverse (__objc_class_tree_list->head,
806 0, __objc_send_load);
807 objc_postorder_traverse (__objc_class_tree_list->head,
808 0, __objc_destroy_class_tree_node);
809 list_remove_head (&__objc_class_tree_list);
812 /* For each module, call the _objc_load_callback if any is
814 list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_load_callback);
816 /* Empty the list of modules. */
817 list_free (__objc_module_list);
818 __objc_module_list = NULL;
822 __objc_create_classes_tree (struct objc_module *module)
824 /* The runtime mutex is locked at this point */
825 struct objc_symtab *symtab = module->symtab;
828 /* Iterate thru classes defined in this module and insert them in
829 the classes tree hierarchy. */
830 for (i = 0; i < symtab->cls_def_cnt; i++)
832 Class class = (Class) symtab->defs[i];
834 if (!objc_hash_is_key_in_hash (duplicate_classes, class))
835 objc_tree_insert_class (class);
838 /* Now iterate over "claimed" categories too (ie, categories that
839 extend a class that has already been loaded by the runtime), and
840 insert them in the classes tree hiearchy too. Otherwise, if you
841 add a category, its +load method would not be called if the class
842 is already loaded in the runtime. It the category is
843 "unclaimed", ie, we haven't loaded the main class yet, postpone
844 sending +load as we want to execute +load from the class before
845 we execute the one from the category. */
846 for (i = 0; i < symtab->cat_def_cnt; ++i)
848 struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
849 Class class = objc_getClass (category->class_name);
851 /* If the class for the category exists then append its
854 objc_tree_insert_class (class);
859 __objc_call_load_callback (struct objc_module *module)
861 if (_objc_load_callback)
863 /* The runtime mutex is locked at this point. */
864 struct objc_symtab *symtab = module->symtab;
867 /* Iterate thru classes defined in this module and call the callback
869 for (i = 0; i < symtab->cls_def_cnt; i++)
871 Class class = (Class) symtab->defs[i];
873 if (!objc_hash_is_key_in_hash (duplicate_classes, class))
875 /* Call the _objc_load_callback for this class. */
876 DEBUG_PRINTF (" calling the load callback for class '%s'\n", class->name);
877 _objc_load_callback (class, 0);
881 /* Call the _objc_load_callback for categories. Don't register
882 the instance methods as class methods for categories to root
883 classes since they were already added in the class. */
884 for (i = 0; i < symtab->cat_def_cnt; i++)
886 struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
887 Class class = objc_getClass (category->class_name);
889 DEBUG_PRINTF (" calling the load callback for category '%s (%s)'\n",
890 category->class_name, category->category_name);
891 _objc_load_callback (class, category);
896 /* Sanity check the version of gcc used to compile `module'. */
898 init_check_module_version (struct objc_module *module)
900 if ((module->version != OBJC_VERSION) || (module->size != sizeof (struct objc_module)))
902 _objc_abort ("Module %s version %d doesn't match runtime %d\n",
903 module->name, (int)module->version, OBJC_VERSION);
907 /* __objc_init_class must be called with __objc_runtime_mutex already
908 locked. Return YES if the class could be setup; return NO if the
909 class could not be setup because a class with the same name already
912 __objc_init_class (Class class)
914 /* Store the class in the class table and assign class numbers. */
915 if (__objc_add_class_to_hash (class))
917 /* Register all of the selectors in the class and meta class. */
918 __objc_register_selectors_from_class (class);
919 __objc_register_selectors_from_class ((Class) class->class_pointer);
921 /* Install the fake dispatch tables. */
922 __objc_install_premature_dtable (class);
923 __objc_install_premature_dtable (class->class_pointer);
925 /* Register the instance methods as class methods, this is only
926 done for root classes. */
927 __objc_register_instance_methods_to_class (class);
929 if (class->protocols)
930 __objc_init_protocols (class->protocols);
936 /* The module contains a duplicate class. Remember it so that
937 we will ignore it later. */
938 DEBUG_PRINTF (" duplicate class '%s' - will be ignored\n", class->name);
939 objc_hash_add (&duplicate_classes, class, class);
944 /* __objc_init_protocol must be called with __objc_runtime_mutex
945 already locked, and the "Protocol" class already registered. */
947 __objc_init_protocol (struct objc_protocol *protocol)
949 static Class proto_class = 0;
952 proto_class = objc_getClass ("Protocol");
954 if (((size_t)protocol->class_pointer) == PROTOCOL_VERSION)
956 /* Assign class pointer. */
957 protocol->class_pointer = proto_class;
959 /* Register all the selectors in the protocol with the runtime.
960 This both registers the selectors with the right types, and
961 it also fixes up the 'struct objc_method' structures inside
962 the protocol so that each method_name (a char * as compiled
963 by the compiler) is replaced with the appropriate runtime
965 if (protocol->class_methods)
966 __objc_register_selectors_from_description_list (protocol->class_methods);
968 if (protocol->instance_methods)
969 __objc_register_selectors_from_description_list (protocol->instance_methods);
971 /* Register the protocol in the hashtable or protocols by
973 __objc_protocols_add_protocol (protocol->protocol_name, protocol);
975 /* Init super protocols. */
976 __objc_init_protocols (protocol->protocol_list);
978 else if (protocol->class_pointer != proto_class)
980 _objc_abort ("Version %d doesn't match runtime protocol version %d\n",
981 (int) ((char *) protocol->class_pointer
988 __objc_init_protocols (struct objc_protocol_list *protos)
991 static Class proto_class = 0;
996 objc_mutex_lock (__objc_runtime_mutex);
999 proto_class = objc_getClass ("Protocol");
1003 unclaimed_proto_list = list_cons (protos, unclaimed_proto_list);
1004 objc_mutex_unlock (__objc_runtime_mutex);
1009 assert (protos->next == 0); /* Only single ones allowed. */
1012 for (i = 0; i < protos->count; i++)
1014 struct objc_protocol *aProto = protos->list[i];
1015 __objc_init_protocol (aProto);
1018 objc_mutex_unlock (__objc_runtime_mutex);
1022 __objc_class_add_protocols (Class class, struct objc_protocol_list *protos)
1027 protos->next = class->protocols;
1028 class->protocols = protos;