OSDN Git Service

ff47f8103f9b9dc8e098a30d6af97d2e1c17c4cf
[pf3gnuchains/gcc-fork.git] / libobjc / init.c
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>
6
7 This file is part of GCC.
8
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.
12
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
16 details.
17
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.
21
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/>.  */
26
27 #include "objc-private/common.h"
28 #include "objc-private/error.h"
29 #include "objc/runtime.h"
30 #include "objc/thr.h"
31 #include "objc-private/hash.h"
32 #include "objc-private/objc-list.h" 
33 #include "objc-private/module-abi-8.h" 
34 #include "objc-private/runtime.h"
35 #include "objc-private/objc-sync.h" /* For __objc_sync_init() */
36 #include "objc-private/protocols.h" /* For __objc_protocols_init(),
37                                        __objc_protocols_add_protocol()
38                                        __objc_protocols_register_selectors() */
39 #include "objc-private/accessors.h" /* For __objc_accessors_init() */
40
41 /* The version number of this runtime.  This must match the number
42    defined in gcc (objc-act.c).  */
43 #define OBJC_VERSION 8
44 #define PROTOCOL_VERSION 2
45
46 /* This list contains all modules currently loaded into the
47    runtime.  */
48 static struct objc_list *__objc_module_list = 0;        /* !T:MUTEX */
49
50 /* This list contains all proto_list's not yet assigned class
51    links.  */
52 static struct objc_list *unclaimed_proto_list = 0;      /* !T:MUTEX */
53
54 /* List of unresolved static instances.  */
55 static struct objc_list *uninitialized_statics = 0;     /* !T:MUTEX */
56
57 /* Global runtime "write" mutex.  Having a single mutex prevents
58    deadlocks, but reduces concurrency.  To improve concurrency, some
59    groups of functions in the runtime have their own separate mutex
60    (eg, __class_table_lock in class.c); to avoid deadlocks, these
61    routines must make sure that they never acquire any other lock
62    while holding their own local lock.  Ie, they should lock, execute
63    some C code that does not perform any calls to other runtime
64    functions which may potentially lock different locks, then unlock.
65    If they need to perform any calls to other runtime functions that
66    may potentially lock other locks, then they should use the global
67    __objc_runtime_mutex.  */
68 objc_mutex_t __objc_runtime_mutex = 0;
69
70 /* Number of threads that are alive.  */
71 int __objc_runtime_threads_alive = 1;                   /* !T:MUTEX */
72
73 /* Check compiler vs runtime version.  */
74 static void init_check_module_version (struct objc_module *);
75
76 /* Assign isa links to protos.  */
77 static void __objc_init_protocols (struct objc_protocol_list *protos);
78
79 /* Assign isa link to a protocol, and register it.  */
80 static void __objc_init_protocol (struct objc_protocol *protocol);
81
82 /* Add protocol to class.  */
83 static void __objc_class_add_protocols (Class, struct objc_protocol_list *);
84
85 /* This is a hook which is called by __objc_exec_class every time a
86    class or a category is loaded into the runtime.  This may e.g. help
87    a dynamic loader determine the classes that have been loaded when
88    an object file is dynamically linked in.  */
89 /* TODO: This needs to be declared in a public file with the new API.  */
90 void (*_objc_load_callback) (Class class, struct objc_category *category); /* !T:SAFE */
91
92 /* Are all categories/classes resolved?  */
93 BOOL __objc_dangling_categories = NO;           /* !T:UNUSED */
94
95 /* TODO: This needs to go into objc-private/selector.h.  */
96 extern SEL
97 __sel_register_typed_name (const char *name, const char *types, 
98                            struct objc_selector *orig, BOOL is_const);
99
100 /* Sends +load to all classes and categories in certain
101    situations.  */
102 static void objc_send_load (void);
103
104 /* Inserts all the classes defined in module in a tree of classes that
105    resembles the class hierarchy. This tree is traversed in preorder
106    and the classes in its nodes receive the +load message if these
107    methods were not executed before. The algorithm ensures that when
108    the +load method of a class is executed all the superclasses have
109    been already received the +load message.  */
110 static void __objc_create_classes_tree (struct objc_module *module);
111
112 static void __objc_call_callback (struct objc_module *module);
113
114 /* A special version that works only before the classes are completely
115    installed in the runtime.  */
116 static BOOL class_is_subclass_of_class (Class class, Class superclass);
117
118 typedef struct objc_class_tree {
119   Class class;
120   struct objc_list *subclasses; /* `head' is pointer to an objc_class_tree */
121 } objc_class_tree;
122
123 /* This is a linked list of objc_class_tree trees. The head of these
124    trees are root classes (their super class is Nil). These different
125    trees represent different class hierarchies.  */
126 static struct objc_list *__objc_class_tree_list = NULL;
127
128 /* Keeps the +load methods who have been already executed. This hash
129    should not be destroyed during the execution of the program.  */
130 static cache_ptr __objc_load_methods = NULL;
131
132 /* This function is used when building the class tree used to send
133    ordinately the +load message to all classes needing it.  The tree
134    is really needed so that superclasses will get the message before
135    subclasses.
136
137    This tree will contain classes which are being loaded (or have just
138    being loaded), and whose super_class pointers have not yet been
139    resolved.  This implies that their super_class pointers point to a
140    string with the name of the superclass; when the first message is
141    sent to the class (/an object of that class) the class links will
142    be resolved, which will replace the super_class pointers with
143    pointers to the actual superclasses.
144
145    Unfortunately, the tree might also contain classes which had been
146    loaded previously, and whose class links have already been
147    resolved.
148
149    This function returns the superclass of a class in both cases, and
150    can be used to build the determine the class relationships while
151    building the tree.  */
152 static Class  class_superclass_of_class (Class class)
153 {
154   char *super_class_name;
155
156   /* If the class links have been resolved, use the resolved
157      links.  */
158   if (CLS_ISRESOLV (class))
159     return class->super_class;
160   
161   /* Else, 'class' has not yet been resolved.  This means that its
162      super_class pointer is really the name of the super class (rather
163      than a pointer to the actual superclass).  */
164   super_class_name = (char *)class->super_class;
165
166   /* Return Nil for a root class.  */
167   if (super_class_name == NULL)
168     return Nil;
169
170   /* Lookup the superclass of non-root classes.  */
171   return objc_getClass (super_class_name);
172 }
173
174
175 /* Creates a tree of classes whose topmost class is directly inherited
176    from `upper' and the bottom class in this tree is
177    `bottom_class'. The classes in this tree are super classes of
178    `bottom_class'. `subclasses' member of each tree node point to the
179    next subclass tree node.  */
180 static objc_class_tree *
181 create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper)
182 {
183   Class superclass;
184   objc_class_tree *tree, *prev;
185
186   if (bottom_class->super_class)
187     superclass = objc_getClass ((char *) bottom_class->super_class);
188   else
189     superclass = Nil;
190
191   DEBUG_PRINTF ("create_tree_of_subclasses_inherited_from:");
192   DEBUG_PRINTF ("bottom_class = %s, upper = %s\n",
193                 (bottom_class ? bottom_class->name : NULL),
194                 (upper ? upper->name : NULL));
195
196   tree = prev = objc_calloc (1, sizeof (objc_class_tree));
197   prev->class = bottom_class;
198
199   while (superclass != upper)
200     {
201       tree = objc_calloc (1, sizeof (objc_class_tree));
202       tree->class = superclass;
203       tree->subclasses = list_cons (prev, tree->subclasses);
204       superclass = class_superclass_of_class (superclass);
205       prev = tree;
206     }
207
208   return tree;
209 }
210
211 /* Insert the `class' into the proper place in the `tree' class
212    hierarchy. This function returns a new tree if the class has been
213    successfully inserted into the tree or NULL if the class is not
214    part of the classes hierarchy described by `tree'. This function is
215    private to objc_tree_insert_class (), you should not call it
216    directly.  */
217 static objc_class_tree *
218 __objc_tree_insert_class (objc_class_tree *tree, Class class)
219 {
220   DEBUG_PRINTF ("__objc_tree_insert_class: tree = %x, class = %s\n",
221                 tree, class->name);
222
223   if (tree == NULL)
224     return create_tree_of_subclasses_inherited_from (class, NULL);
225   else if (class == tree->class)
226     {
227       /* `class' has been already inserted.  */
228       DEBUG_PRINTF ("1. class %s was previously inserted\n", class->name);
229       return tree;
230     }
231   else if (class_superclass_of_class (class) == tree->class)
232     {
233       /* If class is a direct subclass of tree->class then add class
234          to the list of subclasses. First check to see if it wasn't
235          already inserted.  */
236       struct objc_list *list = tree->subclasses;
237       objc_class_tree *node;
238
239       while (list)
240         {
241           /* Class has been already inserted; do nothing just return
242              the tree.  */
243           if (((objc_class_tree *) list->head)->class == class)
244             {
245               DEBUG_PRINTF ("2. class %s was previously inserted\n",
246                             class->name);
247               return tree;
248             }
249           list = list->tail;
250         }
251
252       /* Create a new node class and insert it into the list of
253          subclasses.  */
254       node = objc_calloc (1, sizeof (objc_class_tree));
255       node->class = class;
256       tree->subclasses = list_cons (node, tree->subclasses);
257       DEBUG_PRINTF ("3. class %s inserted\n", class->name);
258       return tree;
259     }
260   else
261     {
262       /* The class is not a direct subclass of tree->class.  Search
263          for class's superclasses in the list of subclasses.  */
264       struct objc_list *subclasses = tree->subclasses;
265
266       /* Precondition: the class must be a subclass of tree->class;
267          otherwise return NULL to indicate our caller that it must
268          take the next tree.  */
269       if (! class_is_subclass_of_class (class, tree->class))
270         return NULL;
271
272       for (; subclasses != NULL; subclasses = subclasses->tail)
273         {
274           Class aClass = ((objc_class_tree *) (subclasses->head))->class;
275
276           if (class_is_subclass_of_class (class, aClass))
277             {
278               /* If we found one of class's superclasses we insert the
279                  class into its subtree and return the original tree
280                  since nothing has been changed.  */
281               subclasses->head
282                   = __objc_tree_insert_class (subclasses->head, class);
283               DEBUG_PRINTF ("4. class %s inserted\n", class->name);
284               return tree;
285             }
286         }
287
288       /* We haven't found a subclass of `class' in the `subclasses'
289          list.  Create a new tree of classes whose topmost class is a
290          direct subclass of tree->class.  */
291       {
292         objc_class_tree *new_tree
293           = create_tree_of_subclasses_inherited_from (class, tree->class);
294         tree->subclasses = list_cons (new_tree, tree->subclasses);
295         DEBUG_PRINTF ("5. class %s inserted\n", class->name);
296         return tree;
297       }
298     }
299 }
300
301 /* This function inserts `class' in the right tree hierarchy classes.  */
302 static void
303 objc_tree_insert_class (Class class)
304 {
305   struct objc_list *list_node;
306   objc_class_tree *tree;
307
308   list_node = __objc_class_tree_list;
309   while (list_node)
310     {
311       tree = __objc_tree_insert_class (list_node->head, class);
312       if (tree)
313         {
314           list_node->head = tree;
315           break;
316         }
317       else
318         list_node = list_node->tail;
319     }
320
321   /* If the list was finished but the class hasn't been inserted,
322      insert it here.  */
323   if (! list_node)
324     {
325       __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
326       __objc_class_tree_list->head = __objc_tree_insert_class (NULL, class);
327     }
328 }
329
330 /* Traverse tree in preorder. Used to send +load.  */
331 static void
332 objc_preorder_traverse (objc_class_tree *tree,
333                         int level,
334                         void (*function) (objc_class_tree *, int))
335 {
336   struct objc_list *node;
337
338   (*function) (tree, level);
339   for (node = tree->subclasses; node; node = node->tail)
340     objc_preorder_traverse (node->head, level + 1, function);
341 }
342
343 /* Traverse tree in postorder. Used to destroy a tree.  */
344 static void
345 objc_postorder_traverse (objc_class_tree *tree,
346                          int level,
347                          void (*function) (objc_class_tree *, int))
348 {
349   struct objc_list *node;
350
351   for (node = tree->subclasses; node; node = node->tail)
352     objc_postorder_traverse (node->head, level + 1, function);
353   (*function) (tree, level);
354 }
355
356 /* Used to print a tree class hierarchy.  */
357 #ifdef DEBUG
358 static void
359 __objc_tree_print (objc_class_tree *tree, int level)
360 {
361   int i;
362
363   for (i = 0; i < level; i++)
364     printf ("  ");
365   printf ("%s\n", tree->class->name);
366 }
367 #endif
368
369 /* Walks on a linked list of methods in the reverse order and executes
370    all the methods corresponding to `op' selector. Walking in the
371    reverse order assures the +load of class is executed first and then
372    +load of categories because of the way in which categories are
373    added to the class methods.  */
374 static void
375 __objc_send_message_in_list (struct objc_method_list *method_list, Class class, SEL op)
376 {
377   int i;
378
379   if (! method_list)
380     return;
381
382   /* First execute the `op' message in the following method lists.  */
383   __objc_send_message_in_list (method_list->method_next, class, op);
384
385   /* Search the method list.  */
386   for (i = 0; i < method_list->method_count; i++)
387     {
388       struct objc_method *mth = &method_list->method_list[i];
389
390       if (mth->method_name && sel_eq (mth->method_name, op)
391           && ! objc_hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
392         {
393           /* Add this method into the +load hash table.  */
394           objc_hash_add (&__objc_load_methods,
395                          mth->method_imp,
396                          mth->method_imp);
397           
398           DEBUG_PRINTF ("sending +load in class: %s\n", class->name);
399           
400           /* The method was found and wasn't previously executed.  */
401           (*mth->method_imp) ((id)class, mth->method_name);
402
403           break;
404         }
405     }
406 }
407
408 static void
409 __objc_send_load (objc_class_tree *tree,
410                   int level __attribute__ ((__unused__)))
411 {
412   static SEL load_sel = 0;
413   Class class = tree->class;
414   struct objc_method_list *method_list = class->class_pointer->methods;
415
416   if (! load_sel)
417     load_sel = sel_registerName ("load");
418
419   __objc_send_message_in_list (method_list, class, load_sel);
420 }
421
422 static void
423 __objc_destroy_class_tree_node (objc_class_tree *tree,
424                                 int level __attribute__ ((__unused__)))
425 {
426   objc_free (tree);
427 }
428
429 /* This is used to check if the relationship between two classes
430    before the runtime completely installs the classes.  */
431 static BOOL
432 class_is_subclass_of_class (Class class, Class superclass)
433 {
434   for (; class != Nil;)
435     {
436       if (class == superclass)
437         return YES;
438       class = class_superclass_of_class (class);
439     }
440
441   return NO;
442 }
443
444 /* This list contains all the classes in the runtime system for whom
445    their superclasses are not yet known to the runtime.  */
446 static struct objc_list *unresolved_classes = 0;
447
448 /* Extern function used to reference the Object class.  */
449 extern void __objc_force_linking (void);
450
451 void
452 __objc_force_linking (void)
453 {
454   extern void __objc_linking (void);
455   __objc_linking ();
456 }
457
458 /* Run through the statics list, removing modules as soon as all its
459    statics have been initialized.  */
460 static void
461 objc_init_statics (void)
462 {
463   struct objc_list **cell = &uninitialized_statics;
464   struct objc_static_instances **statics_in_module;
465
466   objc_mutex_lock (__objc_runtime_mutex);
467
468   while (*cell)
469     {
470       int module_initialized = 1;
471
472       for (statics_in_module = (*cell)->head;
473            *statics_in_module; statics_in_module++)
474         {
475           struct objc_static_instances *statics = *statics_in_module;
476           Class class = objc_getClass (statics->class_name);
477
478           if (! class)
479             {
480               /* It is unfortunate that this will cause all the
481                  statics initialization to be done again (eg, if we
482                  already initialized constant strings, and are now
483                  initializing protocols, setting module_initialized to
484                  0 would cause constant strings to be initialized
485                  again).  It would be good to be able to track if we
486                  have already initialized some of them.  */
487               module_initialized = 0;
488             }
489           else
490             {
491               /* Note that if this is a list of Protocol objects, some
492                  of them may have been initialized already (because
493                  they were attached to classes or categories, and the
494                  class/category loading code automatically fixes them
495                  up), and some of them may not.  We really need to go
496                  through the whole list to be sure!  Protocols are
497                  also special because we want to register them and
498                  register all their selectors.  */
499               id *inst;
500
501               if (strcmp (statics->class_name, "Protocol") == 0)
502                 {
503                   /* Protocols are special, because not only we want
504                      to fix up their class pointers, but we also want
505                      to register them and their selectors with the
506                      runtime.  */
507                   for (inst = &statics->instances[0]; *inst; inst++)
508                     __objc_init_protocol ((struct objc_protocol *)*inst);
509                 }
510               else
511                 {
512                   /* Other static instances (typically constant
513                      strings) are easier as we just fix up their class
514                      pointers.  */
515                   for (inst = &statics->instances[0]; *inst; inst++)              
516                     (*inst)->class_pointer = class;
517                 }
518             }
519         }
520       if (module_initialized)
521         {
522           /* Remove this module from the uninitialized list.  */
523           struct objc_list *this = *cell;
524           *cell = this->tail;
525           objc_free (this);
526         }
527       else
528         cell = &(*cell)->tail;
529     }
530
531   objc_mutex_unlock (__objc_runtime_mutex);
532 }
533
534 /* This function is called by constructor functions generated for each
535    module compiled.  (_GLOBAL_$I$...) The purpose of this function is
536    to gather the module pointers so that they may be processed by the
537    initialization routines as soon as possible.  */
538 void
539 __objc_exec_class (struct objc_module *module)
540 {
541   /* Have we processed any constructors previously?  This flag is used
542      to indicate that some global data structures need to be
543      built.  */
544   static BOOL previous_constructors = 0;
545
546   static struct objc_list *unclaimed_categories = 0;
547
548   /* The symbol table (defined in objc-private/module-abi-8.h)
549      generated by gcc.  */
550   struct objc_symtab *symtab = module->symtab;
551
552   /* The statics in this module.  */
553   struct objc_static_instances **statics
554     = symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt];
555
556   /* Entry used to traverse hash lists.  */
557   struct objc_list **cell;
558
559   /* The table of selector references for this module.  */
560   SEL selectors = symtab->refs; 
561
562   int i;
563
564   DEBUG_PRINTF ("received module: %s\n", module->name);
565
566   /* Check gcc version.  */
567   init_check_module_version (module);
568
569   /* On the first call of this routine, initialize some data
570      structures.  */
571   if (! previous_constructors)
572     {
573         /* Initialize thread-safe system.  */
574       __objc_init_thread_system ();
575       __objc_runtime_threads_alive = 1;
576       __objc_runtime_mutex = objc_mutex_allocate ();
577
578       __objc_init_selector_tables ();
579       __objc_init_class_tables ();
580       __objc_init_dispatch_tables ();
581       __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
582       __objc_load_methods = objc_hash_new (128, 
583                                            (hash_func_type)objc_hash_ptr,
584                                            objc_compare_ptrs);
585       __objc_protocols_init ();
586       __objc_accessors_init ();
587       __objc_sync_init ();
588       previous_constructors = 1;
589     }
590
591   /* Save the module pointer for later processing. (not currently
592      used).  */
593   objc_mutex_lock (__objc_runtime_mutex);
594   __objc_module_list = list_cons (module, __objc_module_list);
595
596   /* Replace referenced selectors from names to SEL's.  */
597   if (selectors)
598     {
599       for (i = 0; selectors[i].sel_id; ++i)
600         {
601           const char *name, *type;
602           name = (char *) selectors[i].sel_id;
603           type = (char *) selectors[i].sel_types;
604           /* Constructors are constant static data so we can safely
605              store pointers to them in the runtime
606              structures. is_const == YES.  */
607           __sel_register_typed_name (name, type, 
608                                      (struct objc_selector *) &(selectors[i]),
609                                      YES);
610         }
611     }
612
613   /* Parse the classes in the load module and gather selector
614      information.  */
615   DEBUG_PRINTF ("gathering selectors from module: %s\n", module->name);
616   for (i = 0; i < symtab->cls_def_cnt; ++i)
617     {
618       Class class = (Class) symtab->defs[i];
619       const char *superclass = (char *) class->super_class;
620
621       /* Make sure we have what we think.  */
622       assert (CLS_ISCLASS (class));
623       assert (CLS_ISMETA (class->class_pointer));
624       DEBUG_PRINTF ("phase 1, processing class: %s\n", class->name);
625
626       /* Initialize the subclass list to be NULL.  In some cases it
627          isn't and this crashes the program.  */
628       class->subclass_list = NULL;
629
630       __objc_init_class (class);
631
632       /* Check to see if the superclass is known in this point. If
633          it's not add the class to the unresolved_classes list.  */
634       if (superclass && ! objc_getClass (superclass))
635         unresolved_classes = list_cons (class, unresolved_classes);
636    }
637
638   /* Process category information from the module.  */
639   for (i = 0; i < symtab->cat_def_cnt; ++i)
640     {
641       struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
642       Class class = objc_getClass (category->class_name);
643       
644       /* If the class for the category exists then append its
645          methods.  */
646       if (class)
647         {
648
649           DEBUG_PRINTF ("processing categories from (module,object): %s, %s\n",
650                         module->name,
651                         class->name);
652
653           /* Do instance methods.  */
654           if (category->instance_methods)
655             class_add_method_list (class, category->instance_methods);
656
657           /* Do class methods.  */
658           if (category->class_methods)
659             class_add_method_list ((Class) class->class_pointer, 
660                                    category->class_methods);
661
662           if (category->protocols)
663             {
664               __objc_init_protocols (category->protocols);
665               __objc_class_add_protocols (class, category->protocols);
666             }
667
668           /* Register the instance methods as class methods, this is
669              only done for root classes.  */
670           __objc_register_instance_methods_to_class (class);
671         }
672       else
673         {
674           /* The object to which the category methods belong can't be
675              found.  Save the information.  */
676           unclaimed_categories = list_cons (category, unclaimed_categories);
677         }
678     }
679
680   if (statics)
681     uninitialized_statics = list_cons (statics, uninitialized_statics);
682   if (uninitialized_statics)
683     objc_init_statics ();
684
685   /* Scan the unclaimed category hash.  Attempt to attach any
686      unclaimed categories to objects.  */
687   for (cell = &unclaimed_categories; *cell; )
688     {
689       struct objc_category *category = (*cell)->head;
690       Class class = objc_getClass (category->class_name);
691       
692       if (class)
693         {
694           DEBUG_PRINTF ("attaching stored categories to object: %s\n",
695                         class->name);
696           
697           list_remove_head (cell);
698           
699           if (category->instance_methods)
700             class_add_method_list (class, category->instance_methods);
701           
702           if (category->class_methods)
703             class_add_method_list ((Class) class->class_pointer,
704                                    category->class_methods);
705
706           if (category->protocols)
707             {
708               __objc_init_protocols (category->protocols);
709               __objc_class_add_protocols (class, category->protocols);
710             }
711
712           /* Register the instance methods as class methods, this is
713              only done for root classes.  */
714           __objc_register_instance_methods_to_class (class);
715         }
716       else
717         cell = &(*cell)->tail;
718     }
719   
720   if (unclaimed_proto_list && objc_getClass ("Protocol"))
721     {
722       list_mapcar (unclaimed_proto_list,
723                    (void (*) (void *))__objc_init_protocols);
724       list_free (unclaimed_proto_list);
725       unclaimed_proto_list = 0;
726     }
727
728   objc_send_load ();
729
730   objc_mutex_unlock (__objc_runtime_mutex);
731 }
732
733 static void
734 objc_send_load (void)
735 {
736   if (! __objc_module_list)
737     return;
738  
739   /* Try to find out if all the classes loaded so far also have their
740      superclasses known to the runtime. We suppose that the objects
741      that are allocated in the +load method are in general of a class
742      declared in the same module.  */
743   if (unresolved_classes)
744     {
745       Class class = unresolved_classes->head;
746
747       while (objc_getClass ((char *) class->super_class))
748         {
749           list_remove_head (&unresolved_classes);
750           if (unresolved_classes)
751             class = unresolved_classes->head;
752           else
753             break;
754         }
755
756       /* If we still have classes for whom we don't have yet their
757          super classes known to the runtime we don't send the +load
758          messages.  */
759       if (unresolved_classes)
760         return;
761     }
762
763   /* Special check.  If 'Object', which is used by meta-classes, has
764      not been loaded yet, delay sending of +load.  */
765   if (! objc_getClass ("Object"))
766     return;
767
768   /* Iterate over all modules in the __objc_module_list and call on
769      them the __objc_create_classes_tree function. This function
770      creates a tree of classes that resembles the class hierarchy.  */
771   list_mapcar (__objc_module_list,
772                (void (*) (void *)) __objc_create_classes_tree);
773
774   while (__objc_class_tree_list)
775     {
776 #ifdef DEBUG
777       objc_preorder_traverse (__objc_class_tree_list->head,
778                               0, __objc_tree_print);
779 #endif
780       objc_preorder_traverse (__objc_class_tree_list->head,
781                               0, __objc_send_load);
782       objc_postorder_traverse (__objc_class_tree_list->head,
783                               0, __objc_destroy_class_tree_node);
784       list_remove_head (&__objc_class_tree_list);
785     }
786
787   list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_callback);
788   list_free (__objc_module_list);
789   __objc_module_list = NULL;
790 }
791
792 static void
793 __objc_create_classes_tree (struct objc_module *module)
794 {
795   /* The runtime mutex is locked at this point */
796   struct objc_symtab *symtab = module->symtab;
797   int i;
798
799   /* Iterate thru classes defined in this module and insert them in
800      the classes tree hierarchy.  */
801   for (i = 0; i < symtab->cls_def_cnt; i++)
802     {
803       Class class = (Class) symtab->defs[i];
804
805       objc_tree_insert_class (class);
806     }
807 }
808
809 static void
810 __objc_call_callback (struct objc_module *module)
811 {
812   /* The runtime mutex is locked at this point.  */
813   struct objc_symtab *symtab = module->symtab;
814   int i;
815
816   /* Iterate thru classes defined in this module and call the callback
817      for each one.  */
818   for (i = 0; i < symtab->cls_def_cnt; i++)
819     {
820       Class class = (Class) symtab->defs[i];
821
822       /* Call the _objc_load_callback for this class.  */
823       if (_objc_load_callback)
824         _objc_load_callback (class, 0);
825     }
826
827   /* Call the _objc_load_callback for categories. Don't register the
828      instance methods as class methods for categories to root classes
829      since they were already added in the class.  */
830   for (i = 0; i < symtab->cat_def_cnt; i++)
831     {
832       struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
833       Class class = objc_getClass (category->class_name);
834
835       if (_objc_load_callback)
836         _objc_load_callback (class, category);
837     }
838 }
839
840 /* Sanity check the version of gcc used to compile `module'.  */
841 static void
842 init_check_module_version (struct objc_module *module)
843 {
844   if ((module->version != OBJC_VERSION) || (module->size != sizeof (struct objc_module)))
845     {
846       _objc_abort ("Module %s version %d doesn't match runtime %d\n",
847                    module->name, (int)module->version, OBJC_VERSION);
848     }
849 }
850
851 /* __objc_init_class must be called with __objc_runtime_mutex already locked.  */
852 void
853 __objc_init_class (Class class)
854 {
855   /* Store the class in the class table and assign class numbers.  */
856   __objc_add_class_to_hash (class);
857   
858   /* Register all of the selectors in the class and meta class.  */
859   __objc_register_selectors_from_class (class);
860   __objc_register_selectors_from_class ((Class) class->class_pointer);
861
862   /* Install the fake dispatch tables.  */
863   __objc_install_premature_dtable (class);
864   __objc_install_premature_dtable (class->class_pointer);
865
866   /* Register the instance methods as class methods, this is only done
867      for root classes.  */
868   __objc_register_instance_methods_to_class (class);
869
870   if (class->protocols)
871     __objc_init_protocols (class->protocols);
872 }
873
874 /* __objc_init_protocol must be called with __objc_runtime_mutex
875    already locked, and the "Protocol" class already registered.  */
876 static void
877 __objc_init_protocol (struct objc_protocol *protocol)
878 {
879   static Class proto_class = 0;
880
881   if (! proto_class)
882     proto_class = objc_getClass ("Protocol");
883
884   if (((size_t)protocol->class_pointer) == PROTOCOL_VERSION)
885     {
886       /* Assign class pointer.  */
887       protocol->class_pointer = proto_class;
888       
889       /* Register all the selectors in the protocol with the runtime.
890          This both registers the selectors with the right types, and
891          it also fixes up the 'struct objc_method' structures inside
892          the protocol so that each method_name (a char * as compiled
893          by the compiler) is replaced with the appropriate runtime
894          SEL.  */
895       if (protocol->class_methods)
896         __objc_register_selectors_from_description_list (protocol->class_methods);
897
898       if (protocol->instance_methods)
899         __objc_register_selectors_from_description_list (protocol->instance_methods);
900
901       /* Register the protocol in the hashtable or protocols by
902          name.  */
903       __objc_protocols_add_protocol (protocol->protocol_name, protocol);
904       
905       /* Init super protocols.  */
906       __objc_init_protocols (protocol->protocol_list);
907     }
908   else if (protocol->class_pointer != proto_class)
909     {
910       _objc_abort ("Version %d doesn't match runtime protocol version %d\n",
911                    (int) ((char *) protocol->class_pointer
912                           - (char *) 0),
913                    PROTOCOL_VERSION);
914     }
915 }
916
917 static void
918 __objc_init_protocols (struct objc_protocol_list *protos)
919 {
920   size_t i;
921   static Class proto_class = 0;
922
923   if (! protos)
924     return;
925
926   objc_mutex_lock (__objc_runtime_mutex);
927
928   if (! proto_class)
929     proto_class = objc_getClass ("Protocol");
930
931   if (! proto_class)
932     {
933       unclaimed_proto_list = list_cons (protos, unclaimed_proto_list);
934       objc_mutex_unlock (__objc_runtime_mutex);
935       return;
936     }
937
938 #if 0
939   assert (protos->next == 0); /* Only single ones allowed.  */
940 #endif
941
942   for (i = 0; i < protos->count; i++)
943     {
944       struct objc_protocol *aProto = protos->list[i];
945       __objc_init_protocol (aProto);
946     }
947
948   objc_mutex_unlock (__objc_runtime_mutex);
949 }
950
951 static void
952 __objc_class_add_protocols (Class class, struct objc_protocol_list *protos)
953 {
954   if (! protos)
955     return;
956
957   protos->next = class->protocols;
958   class->protocols = protos;
959 }