/* GNU Objective C Runtime class related functions   Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002     Free Software Foundation, Inc.   Contributed by Kresten Krab Thorup and Dennis Glatting.   Lock-free class table code designed and written from scratch by   Nicola Pero, 2001.This file is part of GCC.GCC is free software; you can redistribute it and/or modify it under theterms of the GNU General Public License as published by the Free SoftwareFoundation; either version 2, or (at your option) any later version.GCC is distributed in the hope that it will be useful, but WITHOUT ANYWARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESSFOR A PARTICULAR PURPOSE.  See the GNU General Public License for moredetails.You should have received a copy of the GNU General Public License along withGCC; see the file COPYING.  If not, write to the Free SoftwareFoundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  *//* As a special exception, if you link this library with files compiled with   GCC to produce an executable, this does not cause the resulting executable   to be covered by the GNU General Public License. This exception does not   however invalidate any other reasons why the executable file might be   covered by the GNU General Public License.  *//*  The code in this file critically affects class method invocation  speed.  This long preamble comment explains why, and the issues  involved.    One of the traditional weaknesses of the GNU Objective-C runtime is  that class method invocations are slow.  The reason is that when you  write    array = [NSArray new];    this gets basically compiled into the equivalent of     array = [(objc_get_class ("NSArray")) new];    objc_get_class returns the class pointer corresponding to the string  `NSArray'; and because of the lookup, the operation is more  complicated and slow than a simple instance method invocation.      Most high performance Objective-C code (using the GNU Objc runtime)  I had the opportunity to read (or write) work around this problem by  caching the class pointer:    Class arrayClass = [NSArray class];    ... later on ...    array = [arrayClass new];  array = [arrayClass new];  array = [arrayClass new];    In this case, you always perform a class lookup (the first one), but  then all the [arrayClass new] methods run exactly as fast as an  instance method invocation.  It helps if you have many class method  invocations to the same class.      The long-term solution to this problem would be to modify the  compiler to output tables of class pointers corresponding to all the  class method invocations, and to add code to the runtime to update  these tables - that should in the end allow class method invocations  to perform precisely as fast as instance method invocations, because  no class lookup would be involved.  I think the Apple Objective-C  runtime uses this technique.  Doing this involves synchronized  modifications in the runtime and in the compiler.      As a first medicine to the problem, I [NP] have redesigned and  rewritten the way the runtime is performing class lookup.  This  doesn't give as much speed as the other (definitive) approach, but  at least a class method invocation now takes approximately 4.5 times  an instance method invocation on my machine (it would take approx 12  times before the rewriting), which is a lot better.    One of the main reason the new class lookup is so faster is because  I implemented it in a way that can safely run multithreaded without  using locks - a so-called `lock-free' data structure.  The atomic  operation is pointer assignment.  The reason why in this problem  lock-free data structures work so well is that you never remove  classes from the table - and the difficult thing with lock-free data  structures is freeing data when is removed from the structures.  */#include "objc/runtime.h"            /* the kitchen sink */#include "objc/sarray.h"#include "objc/objc.h"#include "objc/objc-api.h"#include "objc/thr.h"/* We use a table which maps a class name to the corresponding class * pointer.  The first part of this file defines this table, and * functions to do basic operations on the table.  The second part of * the file implements some higher level Objective-C functionality for * classes by using the functions provided in the first part to manage * the table. *//** ** Class Table Internals **//* A node holding a class */typedef struct class_node{  struct class_node *next;      /* Pointer to next entry on the list.                                   NULL indicates end of list. */    const char *name;             /* The class name string */  int length;                   /* The class name string length */  Class pointer;                /* The Class pointer */  } *class_node_ptr;/* A table containing classes is a class_node_ptr (pointing to the   first entry in the table - if it is NULL, then the table is   empty). *//* We have 1024 tables.  Each table contains all class names which   have the same hash (which is a number between 0 and 1023).  To look   up a class_name, we compute its hash, and get the corresponding   table.  Once we have the table, we simply compare strings directly   till we find the one which we want (using the length first).  The   number of tables is quite big on purpose (a normal big application   has less than 1000 classes), so that you shouldn't normally get any   collisions, and get away with a single comparison (which we can't   avoid since we need to know that you have got the right thing).  */#define CLASS_TABLE_SIZE 1024#define CLASS_TABLE_MASK 1023static class_node_ptr class_table_array[CLASS_TABLE_SIZE];/* The table writing mutex - we lock on writing to avoid conflicts   between different writers, but we read without locks.  That is   possible because we assume pointer assignment to be an atomic   operation.  */static objc_mutex_t __class_table_lock = NULL;/* CLASS_TABLE_HASH is how we compute the hash of a class name.  It is   a macro - *not* a function - arguments *are* modified directly.     INDEX should be a variable holding an int;   HASH should be a variable holding an int;   CLASS_NAME should be a variable holding a (char *) to the class_name.     After the macro is executed, INDEX contains the length of the   string, and HASH the computed hash of the string; CLASS_NAME is   untouched.  */#define CLASS_TABLE_HASH(INDEX, HASH, CLASS_NAME)          \  HASH = 0;                                                  \  for (INDEX = 0; CLASS_NAME[INDEX] != '\0'; INDEX++)        \    {                                                        \      HASH = (HASH << 4) ^ (HASH >> 28) ^ CLASS_NAME[INDEX]; \    }                                                        \                                                             \  HASH = (HASH ^ (HASH >> 10) ^ (HASH >> 20)) & CLASS_TABLE_MASK;/* Setup the table.  */static voidclass_table_setup (void){  /* Start - nothing in the table.  */  memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE);  /* The table writing mutex.  */  __class_table_lock = objc_mutex_allocate ();}/* Insert a class in the table (used when a new class is registered).  */static void class_table_insert (const char *class_name, Class class_pointer){  int hash, length;  class_node_ptr new_node;  /* Find out the class name's hash and length.  */  CLASS_TABLE_HASH (length, hash, class_name);    /* Prepare the new node holding the class.  */  new_node = objc_malloc (sizeof (struct class_node));  new_node->name = class_name;  new_node->length = length;  new_node->pointer = class_pointer;  /* Lock the table for modifications.  */  objc_mutex_lock (__class_table_lock);    /* Insert the new node in the table at the beginning of the table at     class_table_array[hash].  */  new_node->next = class_table_array[hash];  class_table_array[hash] = new_node;    objc_mutex_unlock (__class_table_lock);}/* Replace a class in the table (used only by poseAs:).  */static void class_table_replace (Class old_class_pointer, Class new_class_pointer){  int hash;  class_node_ptr node;  objc_mutex_lock (__class_table_lock);    hash = 0;  node = class_table_array[hash];    while (hash < CLASS_TABLE_SIZE)    {      if (node == NULL)        {          hash++;          if (hash < CLASS_TABLE_SIZE)            {              node = class_table_array[hash];            }        }      else        {          Class class1 = node->pointer;          if (class1 == old_class_pointer)            {              node->pointer = new_class_pointer;            }          node = node->next;        }    }  objc_mutex_unlock (__class_table_lock);}/* Get a class from the table.  This does not need mutex protection.   Currently, this function is called each time you call a static   method, this is why it must be very fast.  */static inline Class class_table_get_safe (const char *class_name){  class_node_ptr node;    int length, hash;  /* Compute length and hash.  */  CLASS_TABLE_HASH (length, hash, class_name);    node = class_table_array[hash];    if (node != NULL)    {      do        {          if (node->length == length)            {              /* Compare the class names.  */              int i;              for (i = 0; i < length; i++)                {                  if ((node->name)[i] != class_name[i])                     {                      break;                    }                }                            if (i == length)                {                  /* They are equal!  */                  return node->pointer;                }            }        }      while ((node = node->next) != NULL);    }  return Nil;}/* Enumerate over the class table.  */struct class_table_enumerator{  int hash;  class_node_ptr node;};static Classclass_table_next (struct class_table_enumerator **e){  struct class_table_enumerator *enumerator = *e;  class_node_ptr next;    if (enumerator == NULL)    {       *e = objc_malloc (sizeof (struct class_table_enumerator));      enumerator = *e;      enumerator->hash = 0;      enumerator->node = NULL;      next = class_table_array[enumerator->hash];    }  else    {      next = enumerator->node->next;    }    if (next != NULL)    {      enumerator->node = next;      return enumerator->node->pointer;    }  else     {      enumerator->hash++;           while (enumerator->hash < CLASS_TABLE_SIZE)        {          next = class_table_array[enumerator->hash];          if (next != NULL)            {              enumerator->node = next;              return enumerator->node->pointer;            }          enumerator->hash++;        }            /* Ok - table finished - done.  */      objc_free (enumerator);      return Nil;    }}#if 0 /* DEBUGGING FUNCTIONS *//* Debugging function - print the class table.  */voidclass_table_print (void){  int i;    for (i = 0; i < CLASS_TABLE_SIZE; i++)    {      class_node_ptr node;            printf ("%d:\n", i);      node = class_table_array[i];