OSDN Git Service

PR ada/60703
[pf3gnuchains/gcc-fork.git] / libobjc / class.c
1 /* GNU Objective C Runtime class related functions
2    Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2009, 2010
3      Free Software Foundation, Inc.
4    Contributed by Kresten Krab Thorup and Dennis Glatting.
5
6    Lock-free class table code designed and written from scratch by
7    Nicola Pero, 2001.
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify it under the
12 terms of the GNU General Public License as published by the Free Software
13 Foundation; either version 3, or (at your option) any later version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
18 details.
19
20 Under Section 7 of GPL version 3, you are granted additional
21 permissions described in the GCC Runtime Library Exception, version
22 3.1, as published by the Free Software Foundation.
23
24 You should have received a copy of the GNU General Public License and
25 a copy of the GCC Runtime Library Exception along with this program;
26 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
27 <http://www.gnu.org/licenses/>.  */
28
29 /* The code in this file critically affects class method invocation
30   speed.  This long preamble comment explains why, and the issues
31   involved.
32
33   One of the traditional weaknesses of the GNU Objective-C runtime is
34   that class method invocations are slow.  The reason is that when you
35   write
36   
37   array = [NSArray new];
38   
39   this gets basically compiled into the equivalent of 
40   
41   array = [(objc_get_class ("NSArray")) new];
42   
43   objc_get_class returns the class pointer corresponding to the string
44   `NSArray'; and because of the lookup, the operation is more
45   complicated and slow than a simple instance method invocation.
46   
47   Most high performance Objective-C code (using the GNU Objc runtime)
48   I had the opportunity to read (or write) work around this problem by
49   caching the class pointer:
50   
51   Class arrayClass = [NSArray class];
52   
53   ... later on ...
54   
55   array = [arrayClass new];
56   array = [arrayClass new];
57   array = [arrayClass new];
58   
59   In this case, you always perform a class lookup (the first one), but
60   then all the [arrayClass new] methods run exactly as fast as an
61   instance method invocation.  It helps if you have many class method
62   invocations to the same class.
63   
64   The long-term solution to this problem would be to modify the
65   compiler to output tables of class pointers corresponding to all the
66   class method invocations, and to add code to the runtime to update
67   these tables - that should in the end allow class method invocations
68   to perform precisely as fast as instance method invocations, because
69   no class lookup would be involved.  I think the Apple Objective-C
70   runtime uses this technique.  Doing this involves synchronized
71   modifications in the runtime and in the compiler.
72   
73   As a first medicine to the problem, I [NP] have redesigned and
74   rewritten the way the runtime is performing class lookup.  This
75   doesn't give as much speed as the other (definitive) approach, but
76   at least a class method invocation now takes approximately 4.5 times
77   an instance method invocation on my machine (it would take approx 12
78   times before the rewriting), which is a lot better.
79
80   One of the main reason the new class lookup is so faster is because
81   I implemented it in a way that can safely run multithreaded without
82   using locks - a so-called `lock-free' data structure.  The atomic
83   operation is pointer assignment.  The reason why in this problem
84   lock-free data structures work so well is that you never remove
85   classes from the table - and the difficult thing with lock-free data
86   structures is freeing data when is removed from the structures.  */
87
88 #include "objc-private/common.h"
89 #include "objc-private/error.h"
90 #include "objc/runtime.h"
91 #include "objc/thr.h"
92 #include "objc-private/module-abi-8.h"  /* For CLS_ISCLASS and similar.  */
93 #include "objc-private/runtime.h"       /* the kitchen sink */
94 #include "objc-private/sarray.h"        /* For sarray_put_at_safe.  */
95 #include "objc-private/selector.h"      /* For sarray_put_at_safe.  */
96 #include <string.h>                     /* For memset */
97
98 /* We use a table which maps a class name to the corresponding class
99    pointer.  The first part of this file defines this table, and
100    functions to do basic operations on the table.  The second part of
101    the file implements some higher level Objective-C functionality for
102    classes by using the functions provided in the first part to manage
103    the table. */
104
105 /**
106  ** Class Table Internals
107  **/
108
109 /* A node holding a class */
110 typedef struct class_node
111 {
112   struct class_node *next;      /* Pointer to next entry on the list.
113                                    NULL indicates end of list. */
114   
115   const char *name;             /* The class name string */
116   int length;                   /* The class name string length */
117   Class pointer;                /* The Class pointer */
118   
119 } *class_node_ptr;
120
121 /* A table containing classes is a class_node_ptr (pointing to the
122    first entry in the table - if it is NULL, then the table is
123    empty). */
124
125 /* We have 1024 tables.  Each table contains all class names which
126    have the same hash (which is a number between 0 and 1023).  To look
127    up a class_name, we compute its hash, and get the corresponding
128    table.  Once we have the table, we simply compare strings directly
129    till we find the one which we want (using the length first).  The
130    number of tables is quite big on purpose (a normal big application
131    has less than 1000 classes), so that you shouldn't normally get any
132    collisions, and get away with a single comparison (which we can't
133    avoid since we need to know that you have got the right thing).  */
134 #define CLASS_TABLE_SIZE 1024
135 #define CLASS_TABLE_MASK 1023
136
137 static class_node_ptr class_table_array[CLASS_TABLE_SIZE];
138
139 /* The table writing mutex - we lock on writing to avoid conflicts
140    between different writers, but we read without locks.  That is
141    possible because we assume pointer assignment to be an atomic
142    operation.  TODO: This is only true under certain circumstances,
143    which should be clarified.  */
144 static objc_mutex_t __class_table_lock = NULL;
145
146 /* CLASS_TABLE_HASH is how we compute the hash of a class name.  It is
147    a macro - *not* a function - arguments *are* modified directly.
148
149    INDEX should be a variable holding an int;
150    HASH should be a variable holding an int;
151    CLASS_NAME should be a variable holding a (char *) to the class_name.  
152
153    After the macro is executed, INDEX contains the length of the
154    string, and HASH the computed hash of the string; CLASS_NAME is
155    untouched.  */
156
157 #define CLASS_TABLE_HASH(INDEX, HASH, CLASS_NAME)          \
158   HASH = 0;                                                  \
159   for (INDEX = 0; CLASS_NAME[INDEX] != '\0'; INDEX++)        \
160     {                                                        \
161       HASH = (HASH << 4) ^ (HASH >> 28) ^ CLASS_NAME[INDEX]; \
162     }                                                        \
163                                                              \
164   HASH = (HASH ^ (HASH >> 10) ^ (HASH >> 20)) & CLASS_TABLE_MASK;
165
166 /* Setup the table.  */
167 static void
168 class_table_setup (void)
169 {
170   /* Start - nothing in the table.  */
171   memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE);
172
173   /* The table writing mutex.  */
174   __class_table_lock = objc_mutex_allocate ();
175 }
176
177
178 /* Insert a class in the table (used when a new class is
179    registered).  */
180 static void 
181 class_table_insert (const char *class_name, Class class_pointer)
182 {
183   int hash, length;
184   class_node_ptr new_node;
185
186   /* Find out the class name's hash and length.  */
187   CLASS_TABLE_HASH (length, hash, class_name);
188   
189   /* Prepare the new node holding the class.  */
190   new_node = objc_malloc (sizeof (struct class_node));
191   new_node->name = class_name;
192   new_node->length = length;
193   new_node->pointer = class_pointer;
194
195   /* Lock the table for modifications.  */
196   objc_mutex_lock (__class_table_lock);
197   
198   /* Insert the new node in the table at the beginning of the table at
199      class_table_array[hash].  */
200   new_node->next = class_table_array[hash];
201   class_table_array[hash] = new_node;
202   
203   objc_mutex_unlock (__class_table_lock);
204 }
205
206 /* Get a class from the table.  This does not need mutex protection.
207    Currently, this function is called each time you call a static
208    method, this is why it must be very fast.  */
209 static inline Class 
210 class_table_get_safe (const char *class_name)
211 {
212   class_node_ptr node;  
213   int length, hash;
214
215   /* Compute length and hash.  */
216   CLASS_TABLE_HASH (length, hash, class_name);
217   
218   node = class_table_array[hash];
219   
220   if (node != NULL)
221     {
222       do
223         {
224           if (node->length == length)
225             {
226               /* Compare the class names.  */
227               int i;
228
229               for (i = 0; i < length; i++)
230                 {
231                   if ((node->name)[i] != class_name[i]) 
232                     break;
233                 }
234               
235               if (i == length)
236                 {
237                   /* They are equal!  */
238                   return node->pointer;
239                 }
240             }
241         }
242       while ((node = node->next) != NULL);
243     }
244
245   return Nil;
246 }
247
248 /* Enumerate over the class table.  */
249 struct class_table_enumerator
250 {
251   int hash;
252   class_node_ptr node;
253 };
254
255
256 static Class
257 class_table_next (struct class_table_enumerator **e)
258 {
259   struct class_table_enumerator *enumerator = *e;
260   class_node_ptr next;
261   
262   if (enumerator == NULL)
263     {
264        *e = objc_malloc (sizeof (struct class_table_enumerator));
265       enumerator = *e;
266       enumerator->hash = 0;
267       enumerator->node = NULL;
268
269       next = class_table_array[enumerator->hash];
270     }
271   else
272     next = enumerator->node->next;
273   
274   if (next != NULL)
275     {
276       enumerator->node = next;
277       return enumerator->node->pointer;
278     }
279   else 
280     {
281       enumerator->hash++;
282      
283       while (enumerator->hash < CLASS_TABLE_SIZE)
284         {
285           next = class_table_array[enumerator->hash];
286           if (next != NULL)
287             {
288               enumerator->node = next;
289               return enumerator->node->pointer;
290             }
291           enumerator->hash++;
292         }
293       
294       /* Ok - table finished - done.  */
295       objc_free (enumerator);
296       return Nil;
297     }
298 }
299
300 #if 0 /* DEBUGGING FUNCTIONS */
301 /* Debugging function - print the class table.  */
302 void
303 class_table_print (void)
304 {
305   int i;
306   
307   for (i = 0; i < CLASS_TABLE_SIZE; i++)
308     {
309       class_node_ptr node;
310       
311       printf ("%d:\n", i);
312       node = class_table_array[i];
313       
314       while (node != NULL)
315         {
316           printf ("\t%s\n", node->name);
317           node = node->next;
318         }
319     }
320 }
321
322 /* Debugging function - print an histogram of number of classes in
323    function of hash key values.  Useful to evaluate the hash function
324    in real cases.  */
325 void
326 class_table_print_histogram (void)
327 {
328   int i, j;
329   int counter = 0;
330   
331   for (i = 0; i < CLASS_TABLE_SIZE; i++)
332     {
333       class_node_ptr node;
334       
335       node = class_table_array[i];
336       
337       while (node != NULL)
338         {
339           counter++;
340           node = node->next;
341         }
342       if (((i + 1) % 50) == 0)
343         {
344           printf ("%4d:", i + 1);
345           for (j = 0; j < counter; j++)
346             printf ("X");
347
348           printf ("\n");
349           counter = 0;
350         }
351     }
352   printf ("%4d:", i + 1);
353   for (j = 0; j < counter; j++)
354     printf ("X");
355
356   printf ("\n");
357 }
358 #endif /* DEBUGGING FUNCTIONS */
359
360 /**
361  ** Objective-C runtime functions
362  **/
363
364 /* From now on, the only access to the class table data structure
365    should be via the class_table_* functions.  */
366
367 /* This is a hook which is called by objc_get_class and
368    objc_lookup_class if the runtime is not able to find the class.
369    This may e.g. try to load in the class using dynamic loading.
370
371    This hook was a public, global variable in the Traditional GNU
372    Objective-C Runtime API (objc/objc-api.h).  The modern GNU
373    Objective-C Runtime API (objc/runtime.h) provides the
374    objc_setGetUnknownClassHandler() function instead.
375 */
376 Class (*_objc_lookup_class) (const char *name) = 0;      /* !T:SAFE */
377
378 /* The handler currently in use.  PS: if both
379    __obj_get_unknown_class_handler and _objc_lookup_class are defined,
380    __objc_get_unknown_class_handler is called first.  */
381 static objc_get_unknown_class_handler
382 __objc_get_unknown_class_handler = NULL;
383
384 objc_get_unknown_class_handler
385 objc_setGetUnknownClassHandler (objc_get_unknown_class_handler 
386                                 new_handler)
387 {
388   objc_get_unknown_class_handler old_handler 
389     = __objc_get_unknown_class_handler;
390   __objc_get_unknown_class_handler = new_handler;
391   return old_handler;
392 }
393
394
395 /* True when class links has been resolved.  */     
396 BOOL __objc_class_links_resolved = NO;                  /* !T:UNUSED */
397
398
399 void
400 __objc_init_class_tables (void)
401 {
402   /* Allocate the class hash table.  */
403   
404   if (__class_table_lock)
405     return;
406   
407   objc_mutex_lock (__objc_runtime_mutex);
408   
409   class_table_setup ();
410
411   objc_mutex_unlock (__objc_runtime_mutex);
412 }  
413
414 /* This function adds a class to the class hash table, and assigns the
415    class a number, unless it's already known.  Return 'YES' if the
416    class was added.  Return 'NO' if the class was already known.  */
417 BOOL
418 __objc_add_class_to_hash (Class class)
419 {
420   Class existing_class;
421
422   objc_mutex_lock (__objc_runtime_mutex);
423
424   /* Make sure the table is there.  */
425   assert (__class_table_lock);
426
427   /* Make sure it's not a meta class.  */
428   assert (CLS_ISCLASS (class));
429
430   /* Check to see if the class is already in the hash table.  */
431   existing_class = class_table_get_safe (class->name);
432
433   if (existing_class)
434     {
435       objc_mutex_unlock (__objc_runtime_mutex);
436       return NO;      
437     }
438   else
439     {
440       /* The class isn't in the hash table.  Add the class and assign
441          a class number.  */
442       static unsigned int class_number = 1;
443       
444       CLS_SETNUMBER (class, class_number);
445       CLS_SETNUMBER (class->class_pointer, class_number);
446
447       ++class_number;
448       class_table_insert (class->name, class);
449
450       objc_mutex_unlock (__objc_runtime_mutex);
451       return YES;
452     }
453 }
454
455 Class
456 objc_getClass (const char *name)
457 {
458   Class class;
459
460   if (name == NULL)
461     return Nil;
462
463   class = class_table_get_safe (name);
464   
465   if (class)
466     return class;
467
468   if (__objc_get_unknown_class_handler)
469     return (*__objc_get_unknown_class_handler) (name);
470
471   if (_objc_lookup_class)
472     return (*_objc_lookup_class) (name);
473
474   return Nil;
475 }
476
477 Class
478 objc_lookUpClass (const char *name)
479 {
480   if (name == NULL)
481     return Nil;
482   else
483     return class_table_get_safe (name);
484 }
485
486 Class
487 objc_getMetaClass (const char *name)
488 {
489   Class class = objc_getClass (name);
490
491   if (class)
492     return class->class_pointer;
493   else
494     return Nil;
495 }
496
497 Class
498 objc_getRequiredClass (const char *name)
499 {
500   Class class = objc_getClass (name);
501
502   if (class)
503     return class;
504   else
505     _objc_abort ("objc_getRequiredClass ('%s') failed: class not found\n", name);
506 }
507
508 int
509 objc_getClassList (Class *returnValue, int maxNumberOfClassesToReturn)
510 {
511   /* Iterate over all entries in the table.  */
512   int hash, count = 0;
513
514   for (hash = 0; hash < CLASS_TABLE_SIZE; hash++)
515     {
516       class_node_ptr node = class_table_array[hash];
517       
518       while (node != NULL)
519         {
520           if (returnValue)
521             {
522               if (count < maxNumberOfClassesToReturn)
523                 returnValue[count] = node->pointer;
524               else
525                 return count;
526             }
527           count++;
528           node = node->next;
529         }
530     }
531   
532   return count;
533 }
534
535 Class
536 objc_allocateClassPair (Class super_class, const char *class_name, size_t extraBytes)
537 {
538   Class new_class;
539   Class new_meta_class;
540
541   if (class_name == NULL)
542     return Nil;
543
544   if (objc_getClass (class_name))
545     return Nil;
546
547   if (super_class)
548     {
549       /* If you want to build a hierarchy of classes, you need to
550          build and register them one at a time.  The risk is that you
551          are able to cause confusion by registering a subclass before
552          the superclass or similar.  */
553       if (CLS_IS_IN_CONSTRUCTION (super_class))
554         return Nil;
555     }
556
557   /* Technically, we should create the metaclass first, then use
558      class_createInstance() to create the class.  That complication
559      would be relevant if we had class variables, but we don't, so we
560      just ignore it and create everything directly and assume all
561      classes have the same size.  */
562   new_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes);
563   new_meta_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes);
564
565   /* We create an unresolved class, similar to one generated by the
566      compiler.  It will be resolved later when we register it.
567
568      Note how the metaclass details are not that important; when the
569      class is resolved, the ones that matter will be fixed up.  */
570   new_class->class_pointer = new_meta_class;
571   new_meta_class->class_pointer = 0;
572
573   if (super_class)
574     {
575       /* Force the name of the superclass in place of the link to the
576          actual superclass, which will be put there when the class is
577          resolved.  */
578       const char *super_class_name = class_getName (super_class);
579       new_class->super_class = (void *)super_class_name;
580       new_meta_class->super_class = (void *)super_class_name;
581     }
582   else
583     {
584       new_class->super_class = (void *)0;
585       new_meta_class->super_class = (void *)0;
586     }
587
588   new_class->name = objc_malloc (strlen (class_name) + 1);
589   strcpy ((char*)new_class->name, class_name);
590   new_meta_class->name = new_class->name;
591
592   new_class->version = 0;
593   new_meta_class->version = 0;
594
595   new_class->info = _CLS_CLASS | _CLS_IN_CONSTRUCTION;
596   new_meta_class->info = _CLS_META | _CLS_IN_CONSTRUCTION;
597
598   if (super_class)
599     new_class->instance_size = super_class->instance_size;
600   else
601     new_class->instance_size = 0;
602   new_meta_class->instance_size = sizeof (struct objc_class);
603
604   return new_class;
605 }
606
607 void
608 objc_registerClassPair (Class class_)
609 {
610   if (class_ == Nil)
611     return;
612
613   if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_)))
614     return;
615
616   if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer)))
617     return;
618
619   objc_mutex_lock (__objc_runtime_mutex);
620
621   if (objc_getClass (class_->name))
622     {
623       objc_mutex_unlock (__objc_runtime_mutex);
624       return;
625     }
626
627   CLS_SET_NOT_IN_CONSTRUCTION (class_);
628   CLS_SET_NOT_IN_CONSTRUCTION (class_->class_pointer);
629
630   __objc_init_class (class_);
631
632   /* Resolve class links immediately.  No point in waiting.  */
633   __objc_resolve_class_links ();
634
635   objc_mutex_unlock (__objc_runtime_mutex);
636 }
637
638 void
639 objc_disposeClassPair (Class class_)
640 {
641   if (class_ == Nil)
642     return;
643
644   if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_)))
645     return;
646
647   if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer)))
648     return;
649
650   /* Undo any class_addIvar().  */
651   if (class_->ivars)
652     {
653       int i;
654       for (i = 0; i < class_->ivars->ivar_count; i++)
655         {
656           struct objc_ivar *ivar = &(class_->ivars->ivar_list[i]);
657
658           objc_free ((char *)ivar->ivar_name);
659           objc_free ((char *)ivar->ivar_type);
660         }
661       
662       objc_free (class_->ivars);
663     }
664
665   /* Undo any class_addMethod().  */
666   if (class_->methods)
667     {
668       struct objc_method_list *list = class_->methods;
669       while (list)
670         {
671           int i;
672           struct objc_method_list *next = list->method_next;
673
674           for (i = 0; i < list->method_count; i++)
675             {
676               struct objc_method *method = &(list->method_list[i]);
677
678               objc_free ((char *)method->method_name);
679               objc_free ((char *)method->method_types);
680             }
681
682           objc_free (list);
683           list = next;
684         }
685     }
686
687   /* Undo any class_addProtocol().  */
688   if (class_->protocols)
689     {
690       struct objc_protocol_list *list = class_->protocols;
691       while (list)
692         {
693           struct objc_protocol_list *next = list->next;
694
695           objc_free (list);
696           list = next;
697         }
698     }
699   
700   /* Undo any class_addMethod() on the meta-class.  */
701   if (class_->class_pointer->methods)
702     {
703       struct objc_method_list *list = class_->class_pointer->methods;
704       while (list)
705         {
706           int i;
707           struct objc_method_list *next = list->method_next;
708
709           for (i = 0; i < list->method_count; i++)
710             {
711               struct objc_method *method = &(list->method_list[i]);
712
713               objc_free ((char *)method->method_name);
714               objc_free ((char *)method->method_types);
715             }
716
717           objc_free (list);
718           list = next;
719         }
720     }
721
722   /* Undo objc_allocateClassPair().  */
723   objc_free ((char *)(class_->name));
724   objc_free (class_->class_pointer);
725   objc_free (class_);
726 }
727
728 /* Traditional GNU Objective-C Runtime API.  Important: this method is
729    called automatically by the compiler while messaging (if using the
730    traditional ABI), so it is worth keeping it fast; don't make it
731    just a wrapper around objc_getClass().  */
732 /* Note that this is roughly equivalent to objc_getRequiredClass().  */
733 /* Get the class object for the class named NAME.  If NAME does not
734    identify a known class, the hook _objc_lookup_class is called.  If
735    this fails, an error message is issued and the system aborts.  */
736 Class
737 objc_get_class (const char *name)
738 {
739   Class class;
740
741   class = class_table_get_safe (name);
742
743   if (class)
744     return class;
745
746   if (__objc_get_unknown_class_handler)
747     class = (*__objc_get_unknown_class_handler) (name);
748
749   if ((!class)  &&  _objc_lookup_class)
750     class = (*_objc_lookup_class) (name);
751
752   if (class)
753     return class;
754   
755   _objc_abort ("objc runtime: cannot find class %s\n", name);
756
757   return 0;
758 }
759
760 /* This is used by the compiler too.  */
761 Class
762 objc_get_meta_class (const char *name)
763 {
764   return objc_get_class (name)->class_pointer;
765 }
766
767 /* This is not used by GCC, but the clang compiler seems to use it
768    when targetting the GNU runtime.  That's wrong, but we have it to
769    be compatible.  */
770 Class
771 objc_lookup_class (const char *name)
772 {
773   return objc_getClass (name);
774 }
775
776 /* This is used when the implementation of a method changes.  It goes
777    through all classes, looking for the ones that have these methods
778    (either method_a or method_b; method_b can be NULL), and reloads
779    the implementation for these.  You should call this with the
780    runtime mutex already locked.  */
781 void
782 __objc_update_classes_with_methods (struct objc_method *method_a, struct objc_method *method_b)
783 {
784   int hash;
785
786   /* Iterate over all classes.  */
787   for (hash = 0; hash < CLASS_TABLE_SIZE; hash++)
788     {
789       class_node_ptr node = class_table_array[hash];
790       
791       while (node != NULL)
792         {
793           /* We execute this loop twice: the first time, we iterate
794              over all methods in the class (instance methods), while
795              the second time we iterate over all methods in the meta
796              class (class methods).  */
797           Class class = Nil;
798           BOOL done = NO;
799
800           while (done == NO)
801             {
802               struct objc_method_list * method_list;
803
804               if (class == Nil)
805                 {
806                   /* The first time, we work on the class.  */
807                   class = node->pointer;
808                 }
809               else
810                 {
811                   /* The second time, we work on the meta class.  */
812                   class = class->class_pointer;
813                   done = YES;
814                 }
815
816               method_list = class->methods;
817
818               while (method_list)
819                 {
820                   int i;
821                   
822                   for (i = 0; i < method_list->method_count; ++i)
823                     {
824                       struct objc_method *method = &method_list->method_list[i];
825                       
826                       /* If the method is one of the ones we are
827                          looking for, update the implementation.  */
828                       if (method == method_a)
829                         sarray_at_put_safe (class->dtable,
830                                             (sidx) method_a->method_name->sel_id,
831                                             method_a->method_imp);
832                       
833                       if (method == method_b)
834                         {
835                           if (method_b != NULL)
836                             sarray_at_put_safe (class->dtable,
837                                                 (sidx) method_b->method_name->sel_id,
838                                                 method_b->method_imp);
839                         }
840                     }
841                   
842                   method_list = method_list->method_next;
843                 }
844             }
845           node = node->next;
846         }
847     }
848 }
849
850 /* Resolve super/subclass links for all classes.  The only thing we
851    can be sure of is that the class_pointer for class objects point to
852    the right meta class objects.  */
853 void
854 __objc_resolve_class_links (void)
855 {
856   struct class_table_enumerator *es = NULL;
857   Class object_class = objc_get_class ("Object");
858   Class class1;
859
860   assert (object_class);
861
862   objc_mutex_lock (__objc_runtime_mutex);
863
864   /* Assign subclass links.  */
865   while ((class1 = class_table_next (&es)))
866     {
867       /* Make sure we have what we think we have.  */
868       assert (CLS_ISCLASS (class1));
869       assert (CLS_ISMETA (class1->class_pointer));
870
871       /* The class_pointer of all meta classes point to Object's meta
872          class.  */
873       class1->class_pointer->class_pointer = object_class->class_pointer;
874
875       if (! CLS_ISRESOLV (class1))
876         {
877           CLS_SETRESOLV (class1);
878           CLS_SETRESOLV (class1->class_pointer);
879               
880           if (class1->super_class)
881             {   
882               Class a_super_class 
883                 = objc_get_class ((char *) class1->super_class);
884               
885               assert (a_super_class);
886               
887               DEBUG_PRINTF ("making class connections for: %s\n",
888                             class1->name);
889               
890               /* Assign subclass links for superclass.  */
891               class1->sibling_class = a_super_class->subclass_list;
892               a_super_class->subclass_list = class1;
893               
894               /* Assign subclass links for meta class of superclass.  */
895               if (a_super_class->class_pointer)
896                 {
897                   class1->class_pointer->sibling_class
898                     = a_super_class->class_pointer->subclass_list;
899                   a_super_class->class_pointer->subclass_list 
900                     = class1->class_pointer;
901                 }
902             }
903           else /* A root class, make its meta object be a subclass of
904                   Object.  */
905             {
906               class1->class_pointer->sibling_class 
907                 = object_class->subclass_list;
908               object_class->subclass_list = class1->class_pointer;
909             }
910         }
911     }
912
913   /* Assign superclass links.  */
914    es = NULL;
915    while ((class1 = class_table_next (&es)))
916     {
917       Class sub_class;
918       for (sub_class = class1->subclass_list; sub_class;
919            sub_class = sub_class->sibling_class)
920         {
921           sub_class->super_class = class1;
922           if (CLS_ISCLASS (sub_class))
923             sub_class->class_pointer->super_class = class1->class_pointer;
924         }
925     }
926
927   objc_mutex_unlock (__objc_runtime_mutex);
928 }
929
930 const char *
931 class_getName (Class class_)
932 {
933   if (class_ == Nil)
934     return "nil";
935
936   return class_->name;
937 }
938
939 BOOL
940 class_isMetaClass (Class class_)
941 {
942   /* CLS_ISMETA includes the check for Nil class_.  */
943   return CLS_ISMETA (class_);
944 }
945
946 /* Even inside libobjc it may be worth using class_getSuperclass
947    instead of accessing class_->super_class directly because it
948    resolves the class links if needed.  If you access
949    class_->super_class directly, make sure to deal with the situation
950    where the class is not resolved yet!  */
951 Class
952 class_getSuperclass (Class class_)
953 {
954   if (class_ == Nil)
955     return Nil;
956
957   /* Classes that are in construction are not resolved, and still have
958      the class name (instead of a class pointer) in the
959      class_->super_class field.  In that case we need to lookup the
960      superclass name to return the superclass.  We can not resolve the
961      class until it is registered.  */
962   if (CLS_IS_IN_CONSTRUCTION (class_))
963     {
964       if (CLS_ISMETA (class_))
965         return object_getClass ((id)objc_lookUpClass ((const char *)(class_->super_class)));
966       else
967         return objc_lookUpClass ((const char *)(class_->super_class));
968     }
969
970   /* If the class is not resolved yet, super_class would point to a
971      string (the name of the super class) as opposed to the actual
972      super class.  In that case, we need to resolve the class links
973      before we can return super_class.  */
974   if (! CLS_ISRESOLV (class_))
975     __objc_resolve_class_links ();
976   
977   return class_->super_class;
978 }
979
980 int
981 class_getVersion (Class class_)
982 {
983   if (class_ == Nil)
984     return 0;
985
986   return (int)(class_->version);
987 }
988
989 void
990 class_setVersion (Class class_, int version)
991 {
992   if (class_ == Nil)
993     return;
994
995   class_->version = version;
996 }
997
998 size_t
999 class_getInstanceSize (Class class_)
1000 {
1001   if (class_ == Nil)
1002     return 0;
1003
1004   return class_->instance_size;
1005 }
1006