libobjc/class.c

   1 /* GNU Objective C Runtime class related functions
   2    Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2009
   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 /*
  30   The code in this file critically affects class method invocation
  31   speed.  This long preamble comment explains why, and the issues
  32   involved.
  33
  34
  35   One of the traditional weaknesses of the GNU Objective-C runtime is
  36   that class method invocations are slow.  The reason is that when you
  37   write
  38
  39   array = [NSArray new];
  40
  41   this gets basically compiled into the equivalent of
  42
  43   array = [(objc_get_class ("NSArray")) new];
  44
  45   objc_get_class returns the class pointer corresponding to the string
  46   `NSArray'; and because of the lookup, the operation is more
  47   complicated and slow than a simple instance method invocation.
  48
  49   Most high performance Objective-C code (using the GNU Objc runtime)
  50   I had the opportunity to read (or write) work around this problem by
  51   caching the class pointer:
  52
  53   Class arrayClass = [NSArray class];
  54
  55   ... later on ...
  56
  57   array = [arrayClass new];
  58   array = [arrayClass new];
  59   array = [arrayClass new];
  60
  61   In this case, you always perform a class lookup (the first one), but
  62   then all the [arrayClass new] methods run exactly as fast as an
  63   instance method invocation.  It helps if you have many class method
  64   invocations to the same class.
  65
  66   The long-term solution to this problem would be to modify the
  67   compiler to output tables of class pointers corresponding to all the
  68   class method invocations, and to add code to the runtime to update
  69   these tables - that should in the end allow class method invocations
  70   to perform precisely as fast as instance method invocations, because
  71   no class lookup would be involved.  I think the Apple Objective-C
  72   runtime uses this technique.  Doing this involves synchronized
  73   modifications in the runtime and in the compiler.
  74
  75   As a first medicine to the problem, I [NP] have redesigned and
  76   rewritten the way the runtime is performing class lookup.  This
  77   doesn't give as much speed as the other (definitive) approach, but
  78   at least a class method invocation now takes approximately 4.5 times
  79   an instance method invocation on my machine (it would take approx 12
  80   times before the rewriting), which is a lot better.
  81
  82   One of the main reason the new class lookup is so faster is because
  83   I implemented it in a way that can safely run multithreaded without
  84   using locks - a so-called `lock-free' data structure.  The atomic
  85   operation is pointer assignment.  The reason why in this problem
  86   lock-free data structures work so well is that you never remove
  87   classes from the table - and the difficult thing with lock-free data
  88   structures is freeing data when is removed from the structures.  */
  89
  90 #include "objc-private/common.h"
  91 #include "objc-private/error.h"
  92 #include "objc/objc.h"
  93 #include "objc/objc-api.h"
  94 #include "objc/thr.h"
  95 #include "objc-private/runtime.h"            /* the kitchen sink */
  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.  */
 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   HASH = 0;                                                  \
 158   for (INDEX = 0; CLASS_NAME[INDEX] != '\0'; INDEX++)        \
 159     {                                                        \
 160       HASH = (HASH << 4) ^ (HASH >> 28) ^ CLASS_NAME[INDEX]; \
 161     }                                                        \
 162                                                              \
 163   HASH = (HASH ^ (HASH >> 10) ^ (HASH >> 20)) & CLASS_TABLE_MASK;
 164
 165 /* Setup the table.  */
 166 static void
 167 class_table_setup (void)
 168 {
 169   /* Start - nothing in the table.  */
 170   memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE);
 171
 172   /* The table writing mutex.  */
 173   __class_table_lock = objc_mutex_allocate ();
 174 }
 175
 176
 177 /* Insert a class in the table (used when a new class is registered).  */
 178 static void
 179 class_table_insert (const char *class_name, Class class_pointer)
 180 {
 181   int hash, length;
 182   class_node_ptr new_node;
 183
 184   /* Find out the class name's hash and length.  */
 185   CLASS_TABLE_HASH (length, hash, class_name);
 186
 187   /* Prepare the new node holding the class.  */
 188   new_node = objc_malloc (sizeof (struct class_node));
 189   new_node->name = class_name;
 190   new_node->length = length;
 191   new_node->pointer = class_pointer;
 192
 193   /* Lock the table for modifications.  */
 194   objc_mutex_lock (__class_table_lock);
 195
 196   /* Insert the new node in the table at the beginning of the table at
 197      class_table_array[hash].  */
 198   new_node->next = class_table_array[hash];
 199   class_table_array[hash] = new_node;
 200
 201   objc_mutex_unlock (__class_table_lock);
 202 }
 203
 204 /* Replace a class in the table (used only by poseAs:).  */
 205 static void
 206 class_table_replace (Class old_class_pointer, Class new_class_pointer)
 207 {
 208   int hash;
 209   class_node_ptr node;
 210
 211   objc_mutex_lock (__class_table_lock);
 212
 213   hash = 0;
 214   node = class_table_array[hash];
 215
 216   while (hash < CLASS_TABLE_SIZE)
 217     {
 218       if (node == NULL)
 219         {
 220           hash++;
 221           if (hash < CLASS_TABLE_SIZE)
 222             {
 223               node = class_table_array[hash];
 224             }
 225         }
 226       else
 227         {
 228           Class class1 = node->pointer;
 229
 230           if (class1 == old_class_pointer)
 231             {
 232               node->pointer = new_class_pointer;
 233             }
 234           node = node->next;
 235         }
 236     }
 237
 238   objc_mutex_unlock (__class_table_lock);
 239 }
 240
 241
 242 /* Get a class from the table.  This does not need mutex protection.
 243    Currently, this function is called each time you call a static
 244    method, this is why it must be very fast.  */
 245 static inline Class
 246 class_table_get_safe (const char *class_name)
 247 {
 248   class_node_ptr node;
 249   int length, hash;
 250
 251   /* Compute length and hash.  */
 252   CLASS_TABLE_HASH (length, hash, class_name);
 253
 254   node = class_table_array[hash];
 255
 256   if (node != NULL)
 257     {
 258       do
 259         {
 260           if (node->length == length)
 261             {
 262               /* Compare the class names.  */
 263               int i;
 264
 265               for (i = 0; i < length; i++)
 266                 {
 267                   if ((node->name)[i] != class_name[i])
 268                     {
 269                       break;
 270                     }
 271                 }
 272
 273               if (i == length)
 274                 {
 275                   /* They are equal!  */
 276                   return node->pointer;
 277                 }
 278             }
 279         }
 280       while ((node = node->next) != NULL);
 281     }
 282
 283   return Nil;
 284 }
 285
 286 /* Enumerate over the class table.  */
 287 struct class_table_enumerator
 288 {
 289   int hash;
 290   class_node_ptr node;
 291 };
 292
 293
 294 static Class
 295 class_table_next (struct class_table_enumerator **e)
 296 {
 297   struct class_table_enumerator *enumerator = *e;
 298   class_node_ptr next;
 299
 300   if (enumerator == NULL)
 301     {
 302        *e = objc_malloc (sizeof (struct class_table_enumerator));
 303       enumerator = *e;
 304       enumerator->hash = 0;
 305       enumerator->node = NULL;
 306
 307       next = class_table_array[enumerator->hash];
 308     }
 309   else
 310     {
 311       next = enumerator->node->next;
 312     }
 313
 314   if (next != NULL)
 315     {
 316       enumerator->node = next;
 317       return enumerator->node->pointer;
 318     }
 319   else
 320     {
 321       enumerator->hash++;
 322
 323       while (enumerator->hash < CLASS_TABLE_SIZE)
 324         {
 325           next = class_table_array[enumerator->hash];
 326           if (next != NULL)
 327             {
 328               enumerator->node = next;
 329               return enumerator->node->pointer;
 330             }
 331           enumerator->hash++;
 332         }
 333
 334       /* Ok - table finished - done.  */
 335       objc_free (enumerator);
 336       return Nil;
 337     }
 338 }
 339
 340 #if 0 /* DEBUGGING FUNCTIONS */
 341 /* Debugging function - print the class table.  */
 342 void
 343 class_table_print (void)
 344 {
 345   int i;
 346
 347   for (i = 0; i < CLASS_TABLE_SIZE; i++)
 348     {
 349       class_node_ptr node;
 350
 351       printf ("%d:\n", i);
 352       node = class_table_array[i];
 353
 354       while (node != NULL)
 355         {
 356           printf ("\t%s\n", node->name);
 357           node = node->next;
 358         }
 359     }
 360 }
 361
 362 /* Debugging function - print an histogram of number of classes in
 363    function of hash key values.  Useful to evaluate the hash function
 364    in real cases.  */
 365 void
 366 class_table_print_histogram (void)
 367 {
 368   int i, j;
 369   int counter = 0;
 370
 371   for (i = 0; i < CLASS_TABLE_SIZE; i++)
 372     {
 373       class_node_ptr node;
 374
 375       node = class_table_array[i];
 376
 377       while (node != NULL)
 378         {
 379           counter++;
 380           node = node->next;
 381         }
 382       if (((i + 1) % 50) == 0)
 383         {
 384           printf ("%4d:", i + 1);
 385           for (j = 0; j < counter; j++)
 386             {
 387               printf ("X");
 388             }
 389           printf ("\n");
 390           counter = 0;
 391         }
 392     }
 393   printf ("%4d:", i + 1);
 394   for (j = 0; j < counter; j++)
 395     {
 396       printf ("X");
 397     }
 398   printf ("\n");
 399 }
 400 #endif /* DEBUGGING FUNCTIONS */
 401
 402 /**
 403  ** Objective-C runtime functions
 404  **/
 405
 406 /* From now on, the only access to the class table data structure
 407    should be via the class_table_* functions.  */
 408
 409 /* This is a hook which is called by objc_get_class and
 410    objc_lookup_class if the runtime is not able to find the class.
 411    This may e.g. try to load in the class using dynamic loading.  */
 412 Class (*_objc_lookup_class) (const char *name) = 0;      /* !T:SAFE */
 413
 414
 415 /* True when class links has been resolved.  */
 416 BOOL __objc_class_links_resolved = NO;                  /* !T:UNUSED */
 417
 418
 419 void
 420 __objc_init_class_tables (void)
 421 {
 422   /* Allocate the class hash table.  */
 423
 424   if (__class_table_lock)
 425     return;
 426
 427   objc_mutex_lock (__objc_runtime_mutex);
 428
 429   class_table_setup ();
 430
 431   objc_mutex_unlock (__objc_runtime_mutex);
 432 }
 433
 434 /* This function adds a class to the class hash table, and assigns the
 435    class a number, unless it's already known.  */
 436 void
 437 __objc_add_class_to_hash (Class class)
 438 {
 439   Class h_class;
 440
 441   objc_mutex_lock (__objc_runtime_mutex);
 442
 443   /* Make sure the table is there.  */
 444   assert (__class_table_lock);
 445
 446   /* Make sure it's not a meta class.  */
 447   assert (CLS_ISCLASS (class));
 448
 449   /* Check to see if the class is already in the hash table.  */
 450   h_class = class_table_get_safe (class->name);
 451   if (! h_class)
 452     {
 453       /* The class isn't in the hash table.  Add the class and assign a class
 454          number.  */
 455       static unsigned int class_number = 1;
 456
 457       CLS_SETNUMBER (class, class_number);
 458       CLS_SETNUMBER (class->class_pointer, class_number);
 459
 460       ++class_number;
 461       class_table_insert (class->name, class);
 462     }
 463
 464   objc_mutex_unlock (__objc_runtime_mutex);
 465 }
 466
 467 /* Get the class object for the class named NAME.  If NAME does not
 468    identify a known class, the hook _objc_lookup_class is called.  If
 469    this fails, nil is returned.  */
 470 Class
 471 objc_lookup_class (const char *name)
 472 {
 473   Class class;
 474
 475   class = class_table_get_safe (name);
 476
 477   if (class)
 478     return class;
 479
 480   if (_objc_lookup_class)
 481     return (*_objc_lookup_class) (name);
 482   else
 483     return 0;
 484 }
 485
 486 /* Get the class object for the class named NAME.  If NAME does not
 487    identify a known class, the hook _objc_lookup_class is called.  If
 488    this fails, an error message is issued and the system aborts.  */
 489 Class
 490 objc_get_class (const char *name)
 491 {
 492   Class class;
 493
 494   class = class_table_get_safe (name);
 495
 496   if (class)
 497     return class;
 498
 499   if (_objc_lookup_class)
 500     class = (*_objc_lookup_class) (name);
 501
 502   if (class)
 503     return class;
 504
 505   /* FIXME: Should we abort the program here ?  */
 506   _objc_abort ("objc runtime: cannot find class %s\n", name);
 507
 508   return 0;
 509 }
 510
 511 MetaClass
 512 objc_get_meta_class (const char *name)
 513 {
 514   return objc_get_class (name)->class_pointer;
 515 }
 516
 517 /* This function provides a way to enumerate all the classes in the
 518    executable.  Pass *ENUM_STATE == NULL to start the enumeration.  The
 519    function will return 0 when there are no more classes.
 520    For example:
 521        id class;
 522        void *es = NULL;
 523        while ((class = objc_next_class (&es)))
 524          ... do something with class;
 525 */
 526 Class
 527 objc_next_class (void **enum_state)
 528 {
 529   Class class;
 530
 531   objc_mutex_lock (__objc_runtime_mutex);
 532
 533   /* Make sure the table is there.  */
 534   assert (__class_table_lock);
 535
 536   class = class_table_next ((struct class_table_enumerator **) enum_state);
 537
 538   objc_mutex_unlock (__objc_runtime_mutex);
 539
 540   return class;
 541 }
 542
 543 /* Resolve super/subclass links for all classes.  The only thing we
 544    can be sure of is that the class_pointer for class objects point to
 545    the right meta class objects.  */
 546 void
 547 __objc_resolve_class_links (void)
 548 {
 549   struct class_table_enumerator *es = NULL;
 550   Class object_class = objc_get_class ("Object");
 551   Class class1;
 552
 553   assert (object_class);
 554
 555   objc_mutex_lock (__objc_runtime_mutex);
 556
 557   /* Assign subclass links.  */
 558   while ((class1 = class_table_next (&es)))
 559     {
 560       /* Make sure we have what we think we have.  */
 561       assert (CLS_ISCLASS (class1));
 562       assert (CLS_ISMETA (class1->class_pointer));
 563
 564       /* The class_pointer of all meta classes point to Object's meta
 565          class.  */
 566       class1->class_pointer->class_pointer = object_class->class_pointer;
 567
 568       if (! CLS_ISRESOLV (class1))
 569         {
 570           CLS_SETRESOLV (class1);
 571           CLS_SETRESOLV (class1->class_pointer);
 572
 573           if (class1->super_class)
 574             {
 575               Class a_super_class
 576                 = objc_get_class ((char *) class1->super_class);
 577
 578               assert (a_super_class);
 579
 580               DEBUG_PRINTF ("making class connections for: %s\n",
 581                             class1->name);
 582
 583               /* Assign subclass links for superclass.  */
 584               class1->sibling_class = a_super_class->subclass_list;
 585               a_super_class->subclass_list = class1;
 586
 587               /* Assign subclass links for meta class of superclass.  */
 588               if (a_super_class->class_pointer)
 589                 {
 590                   class1->class_pointer->sibling_class
 591                     = a_super_class->class_pointer->subclass_list;
 592                   a_super_class->class_pointer->subclass_list
 593                     = class1->class_pointer;
 594                 }
 595             }
 596           else /* A root class, make its meta object be a subclass of
 597                   Object.  */
 598             {
 599               class1->class_pointer->sibling_class
 600                 = object_class->subclass_list;
 601               object_class->subclass_list = class1->class_pointer;
 602             }
 603         }
 604     }
 605
 606   /* Assign superclass links.  */
 607    es = NULL;
 608    while ((class1 = class_table_next (&es)))
 609     {
 610       Class sub_class;
 611       for (sub_class = class1->subclass_list; sub_class;
 612            sub_class = sub_class->sibling_class)
 613         {
 614           sub_class->super_class = class1;
 615           if (CLS_ISCLASS (sub_class))
 616             sub_class->class_pointer->super_class = class1->class_pointer;
 617         }
 618     }
 619
 620   objc_mutex_unlock (__objc_runtime_mutex);
 621 }
 622
 623
 624
 625 #define CLASSOF(c) ((c)->class_pointer)
 626
 627 Class
 628 class_pose_as (Class impostor, Class super_class)
 629 {
 630   if (! CLS_ISRESOLV (impostor))
 631     __objc_resolve_class_links ();
 632
 633   /* Preconditions */
 634   assert (impostor);
 635   assert (super_class);
 636   assert (impostor->super_class == super_class);
 637   assert (CLS_ISCLASS (impostor));
 638   assert (CLS_ISCLASS (super_class));
 639   assert (impostor->instance_size == super_class->instance_size);
 640
 641   {
 642     Class *subclass = &(super_class->subclass_list);
 643
 644     /* Move subclasses of super_class to impostor.  */
 645     while (*subclass)
 646       {
 647         Class nextSub = (*subclass)->sibling_class;
 648
 649         if (*subclass != impostor)
 650           {
 651             Class sub = *subclass;
 652
 653             /* Classes */
 654             sub->sibling_class = impostor->subclass_list;
 655             sub->super_class = impostor;
 656             impostor->subclass_list = sub;
 657
 658             /* It will happen that SUB is not a class object if it is
 659                the top of the meta class hierarchy chain (root
 660                meta-class objects inherit their class object).  If
 661                that is the case... don't mess with the meta-meta
 662                class.  */
 663             if (CLS_ISCLASS (sub))
 664               {
 665                 /* Meta classes */
 666                 CLASSOF (sub)->sibling_class =
 667                   CLASSOF (impostor)->subclass_list;
 668                 CLASSOF (sub)->super_class = CLASSOF (impostor);
 669                 CLASSOF (impostor)->subclass_list = CLASSOF (sub);
 670               }
 671           }
 672
 673         *subclass = nextSub;
 674       }
 675
 676     /* Set subclasses of superclass to be impostor only.  */
 677     super_class->subclass_list = impostor;
 678     CLASSOF (super_class)->subclass_list = CLASSOF (impostor);
 679
 680     /* Set impostor to have no sibling classes.  */
 681     impostor->sibling_class = 0;
 682     CLASSOF (impostor)->sibling_class = 0;
 683   }
 684
 685   /* Check relationship of impostor and super_class is kept.  */
 686   assert (impostor->super_class == super_class);
 687   assert (CLASSOF (impostor)->super_class == CLASSOF (super_class));
 688
 689   /* This is how to update the lookup table.  Regardless of what the
 690      keys of the hashtable is, change all values that are superclass
 691      into impostor.  */
 692
 693   objc_mutex_lock (__objc_runtime_mutex);
 694
 695   class_table_replace (super_class, impostor);
 696
 697   objc_mutex_unlock (__objc_runtime_mutex);
 698
 699   /* Next, we update the dispatch tables...  */
 700   __objc_update_dispatch_table_for_class (CLASSOF (impostor));
 701   __objc_update_dispatch_table_for_class (impostor);
 702
 703   return impostor;
 704 }