libobjc/class.c

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