obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1044 insertions, 0 deletions

diff --git a/libobjc/init.c b/libobjc/init.c
new file mode 100644
index 000000000..23ba41ba1
--- /dev/null
+++ b/libobjc/init.c
@@ -0,0 +1,1044 @@
+/* GNU Objective C Runtime initialization 
+   Copyright (C) 1993, 1995, 1996, 1997, 2002, 2009, 2010
+   Free Software Foundation, Inc.
+   Contributed by Kresten Krab Thorup
+   +load support contributed by Ovidiu Predescu <ovidiu@net-community.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3, or (at your option) any later version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+/* Uncommented the following line to enable debug logging.  Use this
+   only while debugging the runtime.  */
+/* #define DEBUG 1 */
+
+#include "objc-private/common.h"
+#include "objc-private/error.h"
+#include "objc/runtime.h"
+#include "objc/thr.h"
+#include "objc-private/hash.h"
+#include "objc-private/objc-list.h" 
+#include "objc-private/module-abi-8.h" 
+#include "objc-private/runtime.h"   /* For __objc_resolve_class_links().  */
+#include "objc-private/selector.h"  /* For __sel_register_typed_name().  */
+#include "objc-private/objc-sync.h" /* For __objc_sync_init() */
+#include "objc-private/protocols.h" /* For __objc_protocols_init(),
+				       __objc_protocols_add_protocol()
+				       __objc_protocols_register_selectors() */
+#include "objc-private/accessors.h" /* For __objc_accessors_init() */
+
+/* The version number of this runtime.  This must match the number
+   defined in gcc (objc-act.c).  */
+#define OBJC_VERSION 8
+#define PROTOCOL_VERSION 2
+
+/* This list contains modules currently loaded into the runtime and
+   for which the +load method (and the load callback, if any) has not
+   been called yet.  */
+static struct objc_list *__objc_module_list = 0; 	/* !T:MUTEX */
+
+/* This list contains all proto_list's not yet assigned class
+   links.  */
+static struct objc_list *unclaimed_proto_list = 0; 	/* !T:MUTEX */
+
+/* List of unresolved static instances.  */
+static struct objc_list *uninitialized_statics = 0; 	/* !T:MUTEX */
+
+/* List of duplicated classes found while loading modules.  If we find
+   a class twice, we ignore it the second time.  On some platforms,
+   where the order in which modules are loaded is well defined, this
+   allows you to replace a class in a shared library by linking in a
+   new implementation which is loaded in in the right order, and which
+   overrides the existing one.
+
+   Protected by __objc_runtime_mutex.  */
+static cache_ptr duplicate_classes = NULL;
+
+/* Global runtime "write" mutex.  Having a single mutex prevents
+   deadlocks, but reduces concurrency.  To improve concurrency, some
+   groups of functions in the runtime have their own separate mutex
+   (eg, __class_table_lock in class.c); to avoid deadlocks, these
+   routines must make sure that they never acquire any other lock
+   while holding their own local lock.  Ie, they should lock, execute
+   some C code that does not perform any calls to other runtime
+   functions which may potentially lock different locks, then unlock.
+   If they need to perform any calls to other runtime functions that
+   may potentially lock other locks, then they should use the global
+   __objc_runtime_mutex.  */
+objc_mutex_t __objc_runtime_mutex = 0;
+
+/* Number of threads that are alive.  */
+int __objc_runtime_threads_alive = 1;			/* !T:MUTEX */
+
+/* Check compiler vs runtime version.  */
+static void init_check_module_version (struct objc_module *);
+
+/* Assign isa links to protos.  */
+static void __objc_init_protocols (struct objc_protocol_list *protos);
+
+/* Assign isa link to a protocol, and register it.  */
+static void __objc_init_protocol (struct objc_protocol *protocol);
+
+/* Add protocol to class.  */
+static void __objc_class_add_protocols (Class, struct objc_protocol_list *);
+
+/* Load callback hook.  */
+void (*_objc_load_callback) (Class class, struct objc_category *category) = 0; /* !T:SAFE */
+
+/* Are all categories/classes resolved ?  */
+BOOL __objc_dangling_categories = NO;           /* !T:UNUSED */
+
+/* Sends +load to all classes and categories in certain
+   situations.  */
+static void objc_send_load (void);
+
+/* Inserts all the classes defined in module in a tree of classes that
+   resembles the class hierarchy.  This tree is traversed in preorder
+   and the classes in its nodes receive the +load message if these
+   methods were not executed before.  The algorithm ensures that when
+   the +load method of a class is executed all the superclasses have
+   been already received the +load message.  */
+static void __objc_create_classes_tree (struct objc_module *module);
+
+/* Calls the _objc_load_callback for each class and category in the
+   module (if _objc_load_callback is not NULL).  */
+static void __objc_call_load_callback (struct objc_module *module);
+
+/* A special version that works only before the classes are completely
+   installed in the runtime.  */
+static BOOL class_is_subclass_of_class (Class class, Class superclass);
+
+/* This is a node in the class tree hierarchy used to send +load
+   messages.  */
+typedef struct objc_class_tree
+{
+  /* The class corresponding to the node.  */
+  Class class;
+
+  /* This is a linked list of all the direct subclasses of this class.
+     'head' points to a subclass node; 'tail' points to the next
+     objc_list node (whose 'head' points to another subclass node,
+     etc).  */
+  struct objc_list *subclasses;
+} objc_class_tree;
+
+/* This is a linked list of objc_class_tree trees.  The head of these
+   trees are root classes (their super class is Nil).  These different
+   trees represent different class hierarchies.  */
+static struct objc_list *__objc_class_tree_list = NULL;
+
+/* Keeps the +load methods who have been already executed. This hash
+   should not be destroyed during the execution of the program.  */
+static cache_ptr __objc_load_methods = NULL;
+
+/* This function is used when building the class tree used to send
+   ordinately the +load message to all classes needing it.  The tree
+   is really needed so that superclasses will get the message before
+   subclasses.
+
+   This tree may contain classes which are being loaded (or have just
+   being loaded), and whose super_class pointers have not yet been
+   resolved.  This implies that their super_class pointers point to a
+   string with the name of the superclass; when the first message is
+   sent to the class (/an object of that class) the class links will
+   be resolved, which will replace the super_class pointers with
+   pointers to the actual superclasses.
+
+   Unfortunately, the tree might also contain classes which had been
+   loaded previously, and whose class links have already been
+   resolved.
+
+   This function returns the superclass of a class in both cases, and
+   can be used to build the determine the class relationships while
+   building the tree.  */
+static Class  class_superclass_of_class (Class class)
+{
+  char *super_class_name;
+
+  /* If the class links have been resolved, use the resolved
+     links.  */
+  if (CLS_ISRESOLV (class))
+    return class->super_class;
+  
+  /* Else, 'class' has not yet been resolved.  This means that its
+     super_class pointer is really the name of the super class (rather
+     than a pointer to the actual superclass).  */
+  super_class_name = (char *)class->super_class;
+
+  /* Return Nil for a root class.  */
+  if (super_class_name == NULL)
+    return Nil;
+
+  /* Lookup the superclass of non-root classes.  */
+  return objc_getClass (super_class_name);
+}
+
+
+/* Creates a tree of classes whose topmost class is directly inherited
+   from `upper' and the bottom class in this tree is `bottom_class'.
+   If `upper' is Nil, creates a class hierarchy up to a root class.
+   The classes in this tree are super classes of `bottom_class'.  The
+   `subclasses' member of each tree node point to the list of
+   subclasses for the node.  */
+static objc_class_tree *
+create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper)
+{
+  Class superclass;
+  objc_class_tree *tree, *prev;
+
+  DEBUG_PRINTF ("create_tree_of_subclasses_inherited_from:");
+  DEBUG_PRINTF (" bottom_class = %s, upper = %s\n",
+		(bottom_class ? bottom_class->name : NULL),
+		(upper ? upper->name : NULL));
+
+  superclass = class_superclass_of_class (bottom_class);
+
+  prev = objc_calloc (1, sizeof (objc_class_tree));
+  prev->class = bottom_class;
+
+  if (superclass == upper)
+    return prev;
+
+  while (superclass != upper)
+    {
+      tree = objc_calloc (1, sizeof (objc_class_tree));
+      tree->class = superclass;
+      tree->subclasses = list_cons (prev, tree->subclasses);
+      superclass = class_superclass_of_class (superclass);
+      prev = tree;
+    }
+
+  return tree;
+}
+
+/* Insert the `class' into the proper place in the `tree' class
+   hierarchy.  This function returns a new tree if the class has been
+   successfully inserted into the tree or NULL if the class is not
+   part of the classes hierarchy described by `tree'.  This function
+   is private to objc_tree_insert_class (), you should not call it
+   directly.  */
+static objc_class_tree *
+__objc_tree_insert_class (objc_class_tree *tree, Class class)
+{
+  DEBUG_PRINTF ("__objc_tree_insert_class: tree = %p (root: %s), class = %s\n",
+		tree, ((tree && tree->class) ? tree->class->name : "Nil"), class->name);
+
+  if (tree == NULL)
+    return create_tree_of_subclasses_inherited_from (class, NULL);
+  else if (class == tree->class)
+    {
+      /* `class' has been already inserted.  */
+      DEBUG_PRINTF (" 1. class %s was previously inserted\n", class->name);
+      return tree;
+    }
+  else if (class_superclass_of_class (class) == tree->class)
+    {
+      /* If class is a direct subclass of tree->class then add class
+	 to the list of subclasses. First check to see if it wasn't
+	 already inserted.  */
+      struct objc_list *list = tree->subclasses;
+      objc_class_tree *node;
+
+      while (list)
+	{
+	  /* Class has been already inserted; do nothing just return
+	     the tree.  */
+	  if (((objc_class_tree *) list->head)->class == class)
+	    {
+	      DEBUG_PRINTF (" 2. class %s was previously inserted\n",
+			    class->name);
+	      return tree;
+	    }
+	  list = list->tail;
+	}
+
+      /* Create a new node class and insert it into the list of
+	 subclasses.  */
+      node = objc_calloc (1, sizeof (objc_class_tree));
+      node->class = class;
+      tree->subclasses = list_cons (node, tree->subclasses);
+      DEBUG_PRINTF (" 3. class %s inserted\n", class->name);
+      return tree;
+    }
+  else
+    {
+      /* The class is not a direct subclass of tree->class.  Search
+         for class's superclasses in the list of subclasses.  */
+      struct objc_list *subclasses = tree->subclasses;
+
+      /* Precondition: the class must be a subclass of tree->class;
+         otherwise return NULL to indicate our caller that it must
+         take the next tree.  */
+      if (! class_is_subclass_of_class (class, tree->class))
+	return NULL;
+
+      for (; subclasses != NULL; subclasses = subclasses->tail)
+	{
+	  Class aClass = ((objc_class_tree *) (subclasses->head))->class;
+
+	  if (class_is_subclass_of_class (class, aClass))
+	    {
+	      /* If we found one of class's superclasses we insert the
+	         class into its subtree and return the original tree
+	         since nothing has been changed.  */
+	      subclasses->head
+		  = __objc_tree_insert_class (subclasses->head, class);
+ 	      DEBUG_PRINTF (" 4. class %s inserted\n", class->name);
+	      return tree;
+	    }
+	}
+
+      /* We haven't found a subclass of `class' in the `subclasses'
+         list.  Create a new tree of classes whose topmost class is a
+         direct subclass of tree->class.  */
+      {
+	objc_class_tree *new_tree
+	  = create_tree_of_subclasses_inherited_from (class, tree->class);
+	tree->subclasses = list_cons (new_tree, tree->subclasses);
+ 	DEBUG_PRINTF (" 5. class %s inserted\n", class->name);
+	return tree;
+      }
+    }
+}
+
+/* This function inserts `class' in the right tree hierarchy classes.  */
+static void
+objc_tree_insert_class (Class class)
+{
+  struct objc_list *list_node;
+  objc_class_tree *tree;
+  
+  list_node = __objc_class_tree_list;
+  while (list_node)
+    {
+      /* Try to insert the class in this class hierarchy.  */
+      tree = __objc_tree_insert_class (list_node->head, class);
+      if (tree)
+	{
+	  list_node->head = tree;
+	  return;
+	}
+      else
+	list_node = list_node->tail;
+    }
+  
+  /* If the list was finished but the class hasn't been inserted, we
+     don't have an existing class hierarchy that can accomodate it.
+     Create a new one.  */
+  __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
+  __objc_class_tree_list->head = __objc_tree_insert_class (NULL, class);
+}
+
+/* Traverse tree in preorder. Used to send +load.  */
+static void
+objc_preorder_traverse (objc_class_tree *tree,
+			int level,
+			void (*function) (objc_class_tree *, int))
+{
+  struct objc_list *node;
+
+  (*function) (tree, level);
+  for (node = tree->subclasses; node; node = node->tail)
+    objc_preorder_traverse (node->head, level + 1, function);
+}
+
+/* Traverse tree in postorder. Used to destroy a tree.  */
+static void
+objc_postorder_traverse (objc_class_tree *tree,
+			 int level,
+			 void (*function) (objc_class_tree *, int))
+{
+  struct objc_list *node;
+
+  for (node = tree->subclasses; node; node = node->tail)
+    objc_postorder_traverse (node->head, level + 1, function);
+  (*function) (tree, level);
+}
+
+/* Used to print a tree class hierarchy.  */
+#ifdef DEBUG
+static void
+__objc_tree_print (objc_class_tree *tree, int level)
+{
+  int i;
+
+  for (i = 0; i < level; i++)
+    printf ("  ");
+  printf ("%s\n", tree->class->name);
+}
+#endif
+
+/* Walks on a linked list of methods in the reverse order and executes
+   all the methods corresponding to the `+load' selector.  Walking in
+   the reverse order assures the +load of class is executed first and
+   then +load of categories because of the way in which categories are
+   added to the class methods.  This function needs to be called with
+   the objc_runtime_mutex locked.  */
+static void
+__objc_send_load_using_method_list (struct objc_method_list *method_list, Class class)
+{
+  static SEL load_selector = 0;
+  int i;
+
+  if (!method_list)
+    return;
+
+  /* This needs no lock protection because we are called with the
+     objc_runtime_mutex locked.  */
+  if (!load_selector)
+    load_selector = sel_registerName ("load");
+
+  /* method_list is a linked list of method lists; since we're
+     executing in reverse order, we need to do the next list before we
+     do this one.  */
+  __objc_send_load_using_method_list (method_list->method_next, class);
+
+  /* Search the method list.  */
+  for (i = 0; i < method_list->method_count; i++)
+    {
+      struct objc_method *mth = &method_list->method_list[i];
+
+      /* We are searching for +load methods that we haven't executed
+	 yet.  */
+      if (mth->method_name && sel_eq (mth->method_name, load_selector)
+	  && ! objc_hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
+	{
+	  /* Add this method into the +load hash table, so we won't
+	     execute it again next time.  */
+	  objc_hash_add (&__objc_load_methods,
+			 mth->method_imp,
+			 mth->method_imp);
+	  
+	  /* Call +load.  */
+	  DEBUG_PRINTF (" begin of [%s +load]\n", class->name);
+	  (*mth->method_imp) ((id)class, mth->method_name);
+	  DEBUG_PRINTF (" end of [%s +load]\n", class->name);
+
+	  break;
+	}
+    }
+}
+
+/* This function needs to be called with the objc_runtime_mutex
+   locked.  */
+static void
+__objc_send_load (objc_class_tree *tree,
+		  int level __attribute__ ((__unused__)))
+{
+  Class class = tree->class;
+  struct objc_method_list *method_list = class->class_pointer->methods;
+
+  DEBUG_PRINTF ("+load: need to send load to class '%s'\n", class->name);
+  __objc_send_load_using_method_list (method_list, class);
+}
+
+static void
+__objc_destroy_class_tree_node (objc_class_tree *tree,
+				int level __attribute__ ((__unused__)))
+{
+  objc_free (tree);
+}
+
+/* This is used to check if the relationship between two classes
+   before the runtime completely installs the classes.  */
+static BOOL
+class_is_subclass_of_class (Class class, Class superclass)
+{
+  for (; class != Nil;)
+    {
+      if (class == superclass)
+	return YES;
+      class = class_superclass_of_class (class);
+    }
+
+  return NO;
+}
+
+/* This list contains all the classes in the runtime system for whom
+   their superclasses are not yet known to the runtime.  */
+static struct objc_list *unresolved_classes = 0;
+
+/* Extern function used to reference the Object class.  */
+extern void __objc_force_linking (void);
+
+void
+__objc_force_linking (void)
+{
+  extern void __objc_linking (void);
+  __objc_linking ();
+}
+
+/* Run through the statics list, removing modules as soon as all its
+   statics have been initialized.  */
+static void
+objc_init_statics (void)
+{
+  struct objc_list **cell = &uninitialized_statics;
+  struct objc_static_instances **statics_in_module;
+
+  objc_mutex_lock (__objc_runtime_mutex);
+
+  while (*cell)
+    {
+      int module_initialized = 1;
+
+      for (statics_in_module = (*cell)->head;
+	   *statics_in_module; statics_in_module++)
+	{
+	  struct objc_static_instances *statics = *statics_in_module;
+	  Class class = objc_getClass (statics->class_name);
+
+	  if (! class)
+	    {
+	      /* It is unfortunate that this will cause all the
+		 statics initialization to be done again (eg, if we
+		 already initialized constant strings, and are now
+		 initializing protocols, setting module_initialized to
+		 0 would cause constant strings to be initialized
+		 again).  It would be good to be able to track if we
+		 have already initialized some of them.  */
+	      module_initialized = 0;
+	    }
+	  else
+	    {
+	      /* Note that if this is a list of Protocol objects, some
+		 of them may have been initialized already (because
+		 they were attached to classes or categories, and the
+		 class/category loading code automatically fixes them
+		 up), and some of them may not.  We really need to go
+		 through the whole list to be sure!  Protocols are
+		 also special because we want to register them and
+		 register all their selectors.  */
+	      id *inst;
+
+	      if (strcmp (statics->class_name, "Protocol") == 0)
+		{
+		  /* Protocols are special, because not only we want
+		     to fix up their class pointers, but we also want
+		     to register them and their selectors with the
+		     runtime.  */
+		  for (inst = &statics->instances[0]; *inst; inst++)
+		    __objc_init_protocol ((struct objc_protocol *)*inst);
+		}
+	      else
+		{
+		  /* Other static instances (typically constant
+		     strings) are easier as we just fix up their class
+		     pointers.  */
+		  for (inst = &statics->instances[0]; *inst; inst++)		  
+		    (*inst)->class_pointer = class;
+		}
+	    }
+	}
+      if (module_initialized)
+	{
+	  /* Remove this module from the uninitialized list.  */
+	  struct objc_list *this = *cell;
+	  *cell = this->tail;
+	  objc_free (this);
+	}
+      else
+	cell = &(*cell)->tail;
+    }
+
+  objc_mutex_unlock (__objc_runtime_mutex);
+}
+
+/* This function is called by constructor functions generated for each
+   module compiled.  (_GLOBAL_$I$...) The purpose of this function is
+   to gather the module pointers so that they may be processed by the
+   initialization routines as soon as possible.  */
+void
+__objc_exec_class (struct objc_module *module)
+{
+  /* Have we processed any constructors previously?  This flag is used
+     to indicate that some global data structures need to be
+     built.  */
+  static BOOL previous_constructors = 0;
+
+  static struct objc_list *unclaimed_categories = 0;
+
+  /* The symbol table (defined in objc-private/module-abi-8.h)
+     generated by gcc.  */
+  struct objc_symtab *symtab = module->symtab;
+
+  /* The statics in this module.  */
+  struct objc_static_instances **statics
+    = symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt];
+
+  /* Entry used to traverse hash lists.  */
+  struct objc_list **cell;
+
+  /* The table of selector references for this module.  */
+  struct objc_selector *selectors = symtab->refs;
+
+  int i;
+
+  DEBUG_PRINTF ("\n__objc_exec_class (%p) - start processing module...\n", module);
+
+  /* Check gcc version.  */
+  init_check_module_version (module);
+
+  /* On the first call of this routine, initialize some data
+     structures.  */
+  if (! previous_constructors)
+    {
+	/* Initialize thread-safe system.  */
+      __objc_init_thread_system ();
+      __objc_runtime_threads_alive = 1;
+      __objc_runtime_mutex = objc_mutex_allocate ();
+
+      __objc_init_selector_tables ();
+      __objc_init_class_tables ();
+      __objc_init_dispatch_tables ();
+      duplicate_classes = objc_hash_new (8,
+					 (hash_func_type)objc_hash_ptr,
+					 objc_compare_ptrs);
+      __objc_load_methods = objc_hash_new (128, 
+					   (hash_func_type)objc_hash_ptr,
+					   objc_compare_ptrs);
+      __objc_protocols_init ();
+      __objc_accessors_init ();
+      __objc_sync_init ();
+      previous_constructors = 1;
+    }
+
+  /* Save the module pointer so that later we remember to call +load
+     on all classes and categories on it.  */
+  objc_mutex_lock (__objc_runtime_mutex);
+  __objc_module_list = list_cons (module, __objc_module_list);
+
+  /* Replace referenced selectors from names to SELs.  */
+  if (selectors)
+    {
+      DEBUG_PRINTF (" registering selectors\n");
+      __objc_register_selectors_from_module (selectors);
+    }
+
+  /* Parse the classes in the load module and gather selector
+     information.  */
+  for (i = 0; i < symtab->cls_def_cnt; ++i)
+    {
+      Class class = (Class) symtab->defs[i];
+      const char *superclass = (char *) class->super_class;
+
+      /* Make sure we have what we think.  */
+      assert (CLS_ISCLASS (class));
+      assert (CLS_ISMETA (class->class_pointer));
+      DEBUG_PRINTF (" installing class '%s'\n", class->name);
+
+      /* Workaround for a bug in clang: Clang may set flags other than
+	 _CLS_CLASS and _CLS_META even when compiling for the
+	 traditional ABI (version 8), confusing our runtime.  Try to
+	 wipe these flags out.  */
+      if (CLS_ISCLASS (class))
+	__CLS_INFO (class) = _CLS_CLASS;
+      else
+	__CLS_INFO (class) = _CLS_META;
+
+      /* Initialize the subclass list to be NULL.  In some cases it
+	 isn't and this crashes the program.  */
+      class->subclass_list = NULL;
+
+      if (__objc_init_class (class))
+	{
+	  /* Check to see if the superclass is known in this point. If
+	     it's not add the class to the unresolved_classes list.  */
+	  if (superclass && ! objc_getClass (superclass))
+	    unresolved_classes = list_cons (class, unresolved_classes);
+	}
+    }
+
+  /* Process category information from the module.  */
+  for (i = 0; i < symtab->cat_def_cnt; ++i)
+    {
+      struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
+      Class class = objc_getClass (category->class_name);
+      
+      /* If the class for the category exists then append its
+	 methods.  */
+      if (class)
+	{
+	  DEBUG_PRINTF (" installing category '%s (%s)'\n", category->class_name, category->category_name);
+	  /* Do instance methods.  */
+	  if (category->instance_methods)
+	    class_add_method_list (class, category->instance_methods);
+
+	  /* Do class methods.  */
+	  if (category->class_methods)
+	    class_add_method_list ((Class) class->class_pointer, 
+				   category->class_methods);
+
+	  if (category->protocols)
+	    {
+	      __objc_init_protocols (category->protocols);
+	      __objc_class_add_protocols (class, category->protocols);
+	    }
+
+          /* Register the instance methods as class methods, this is
+             only done for root classes.  */
+          __objc_register_instance_methods_to_class (class);
+	}
+      else
+	{
+	  DEBUG_PRINTF (" delaying installation of category '%s (%s)'\n", category->class_name, category->category_name);
+	  /* The object to which the category methods belong can't be
+	     found.  Save the information.  */
+	  unclaimed_categories = list_cons (category, unclaimed_categories);
+	}
+    }
+
+  if (statics)
+    uninitialized_statics = list_cons (statics, uninitialized_statics);
+  if (uninitialized_statics)
+    objc_init_statics ();
+
+  /* Scan the unclaimed category hash.  Attempt to attach any
+     unclaimed categories to objects.  */
+  for (cell = &unclaimed_categories; *cell; )
+    {
+      struct objc_category *category = (*cell)->head;
+      Class class = objc_getClass (category->class_name);
+      
+      if (class)
+	{
+	  DEBUG_PRINTF (" installing (delayed) category '%s (%s)'\n", category->class_name, category->category_name);
+	  list_remove_head (cell);
+	  
+	  if (category->instance_methods)
+	    class_add_method_list (class, category->instance_methods);
+	  
+	  if (category->class_methods)
+	    class_add_method_list ((Class) class->class_pointer,
+				   category->class_methods);
+
+	  if (category->protocols)
+	    {
+	      __objc_init_protocols (category->protocols);
+	      __objc_class_add_protocols (class, category->protocols);
+	    }
+
+          /* Register the instance methods as class methods, this is
+             only done for root classes.  */
+          __objc_register_instance_methods_to_class (class);
+	}
+      else
+	cell = &(*cell)->tail;
+    }
+  
+  if (unclaimed_proto_list && objc_getClass ("Protocol"))
+    {
+      list_mapcar (unclaimed_proto_list,
+		   (void (*) (void *))__objc_init_protocols);
+      list_free (unclaimed_proto_list);
+      unclaimed_proto_list = 0;
+    }
+
+  objc_send_load ();
+
+  /* Check if there are no unresolved classes (ie, classes whose
+     superclass has not been loaded yet) and that the 'Object' class,
+     used as the class of classes, exist.  If so, it is worth
+     "resolving the class links" at this point, which will setup all
+     the class/superclass pointers.  */
+  if (!unresolved_classes && objc_getClass ("Object"))
+    {
+      DEBUG_PRINTF (" resolving class links\n");
+      __objc_resolve_class_links ();
+    }
+
+  objc_mutex_unlock (__objc_runtime_mutex);
+
+  DEBUG_PRINTF ("__objc_exec_class (%p) - finished processing module...\n\n", module);
+}
+
+/* This function needs to be called with the objc_runtime_mutex
+   locked.  */
+static void
+objc_send_load (void)
+{
+  if (!__objc_module_list)
+    return;
+ 
+  /* Try to find out if all the classes loaded so far also have their
+     superclasses known to the runtime.  We suppose that the objects
+     that are allocated in the +load method are in general of a class
+     declared in the same module.  */
+  if (unresolved_classes)
+    {
+      Class class = unresolved_classes->head;
+
+      while (objc_getClass ((char *) class->super_class))
+	{
+	  list_remove_head (&unresolved_classes);
+	  if (unresolved_classes)
+	    class = unresolved_classes->head;
+	  else
+	    break;
+	}
+
+      /* If we still have classes for whom we don't have yet their
+         super classes known to the runtime we don't send the +load
+         messages (and call the load callback) yet.  */
+      if (unresolved_classes)
+	return;
+    }
+
+  /* Special check.  If 'Object', which is used by meta-classes, has
+     not been loaded yet, delay sending of +load.  */
+  if (! objc_getClass ("Object"))
+    return;
+
+  /* Iterate over all modules in the __objc_module_list and call on
+     them the __objc_create_classes_tree function.  This function
+     creates a tree of classes that resembles the class hierarchy.  */
+  list_mapcar (__objc_module_list,
+	       (void (*) (void *)) __objc_create_classes_tree);
+
+  while (__objc_class_tree_list)
+    {
+#ifdef DEBUG
+      objc_preorder_traverse (__objc_class_tree_list->head,
+			      0, __objc_tree_print);
+#endif
+      objc_preorder_traverse (__objc_class_tree_list->head,
+			      0, __objc_send_load);
+      objc_postorder_traverse (__objc_class_tree_list->head,
+			      0, __objc_destroy_class_tree_node);
+      list_remove_head (&__objc_class_tree_list);
+    }
+
+  /* For each module, call the _objc_load_callback if any is
+     defined.  */
+  list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_load_callback);
+
+  /* Empty the list of modules.  */
+  list_free (__objc_module_list);
+  __objc_module_list = NULL;
+}
+
+static void
+__objc_create_classes_tree (struct objc_module *module)
+{
+  /* The runtime mutex is locked at this point */
+  struct objc_symtab *symtab = module->symtab;
+  int i;
+
+  /* Iterate thru classes defined in this module and insert them in
+     the classes tree hierarchy.  */
+  for (i = 0; i < symtab->cls_def_cnt; i++)
+    {
+      Class class = (Class) symtab->defs[i];
+
+      if (!objc_hash_is_key_in_hash (duplicate_classes, class))
+	objc_tree_insert_class (class);
+    }
+
+  /* Now iterate over "claimed" categories too (ie, categories that
+     extend a class that has already been loaded by the runtime), and
+     insert them in the classes tree hiearchy too.  Otherwise, if you
+     add a category, its +load method would not be called if the class
+     is already loaded in the runtime.  It the category is
+     "unclaimed", ie, we haven't loaded the main class yet, postpone
+     sending +load as we want to execute +load from the class before
+     we execute the one from the category.  */
+  for (i = 0; i < symtab->cat_def_cnt; ++i)
+    {
+      struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
+      Class class = objc_getClass (category->class_name);
+      
+      /* If the class for the category exists then append its
+	 methods.  */
+      if (class)
+	objc_tree_insert_class (class);
+    }
+}
+
+static void
+__objc_call_load_callback (struct objc_module *module)
+{
+  if (_objc_load_callback)
+    {
+      /* The runtime mutex is locked at this point.  */
+      struct objc_symtab *symtab = module->symtab;
+      int i;
+      
+      /* Iterate thru classes defined in this module and call the callback
+	 for each one.  */
+      for (i = 0; i < symtab->cls_def_cnt; i++)
+	{
+	  Class class = (Class) symtab->defs[i];
+	
+	  if (!objc_hash_is_key_in_hash (duplicate_classes, class))
+	    {
+	      /* Call the _objc_load_callback for this class.  */
+	      DEBUG_PRINTF (" calling the load callback for class '%s'\n", class->name);
+	      _objc_load_callback (class, 0);
+	    }
+	}
+      
+      /* Call the _objc_load_callback for categories.  Don't register
+	 the instance methods as class methods for categories to root
+	 classes since they were already added in the class.  */
+      for (i = 0; i < symtab->cat_def_cnt; i++)
+	{
+	  struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
+	  Class class = objc_getClass (category->class_name);
+	  
+	  DEBUG_PRINTF (" calling the load callback for category '%s (%s)'\n",
+			category->class_name, category->category_name);
+	  _objc_load_callback (class, category);
+	}
+    }
+}
+
+/* Sanity check the version of gcc used to compile `module'.  */
+static void
+init_check_module_version (struct objc_module *module)
+{
+  if ((module->version != OBJC_VERSION) || (module->size != sizeof (struct objc_module)))
+    {
+      _objc_abort ("Module %s version %d doesn't match runtime %d\n",
+		   module->name, (int)module->version, OBJC_VERSION);
+    }
+}
+
+/* __objc_init_class must be called with __objc_runtime_mutex already
+   locked.  Return YES if the class could be setup; return NO if the
+   class could not be setup because a class with the same name already
+   exists.  */
+BOOL
+__objc_init_class (Class class)
+{
+  /* Store the class in the class table and assign class numbers.  */
+  if (__objc_add_class_to_hash (class))
+    {
+      /* Register all of the selectors in the class and meta class.  */
+      __objc_register_selectors_from_class (class);
+      __objc_register_selectors_from_class ((Class) class->class_pointer);
+      
+      /* Install the fake dispatch tables.  */
+      __objc_install_premature_dtable (class);
+      __objc_install_premature_dtable (class->class_pointer);
+      
+      /* Register the instance methods as class methods, this is only
+	 done for root classes.  */
+      __objc_register_instance_methods_to_class (class);
+      
+      if (class->protocols)
+	__objc_init_protocols (class->protocols);
+
+      return YES;
+    }
+  else
+    {
+      /* The module contains a duplicate class.  Remember it so that
+	 we will ignore it later.  */
+      DEBUG_PRINTF (" duplicate class '%s' - will be ignored\n", class->name);
+      objc_hash_add (&duplicate_classes, class, class);
+      return NO;
+    }
+}
+
+/* __objc_init_protocol must be called with __objc_runtime_mutex
+   already locked, and the "Protocol" class already registered.  */
+static void
+__objc_init_protocol (struct objc_protocol *protocol)
+{
+  static Class proto_class = 0;
+
+  if (! proto_class)
+    proto_class = objc_getClass ("Protocol");
+
+  if (((size_t)protocol->class_pointer) == PROTOCOL_VERSION)
+    {
+      /* Assign class pointer.  */
+      protocol->class_pointer = proto_class;
+      
+      /* Register all the selectors in the protocol with the runtime.
+	 This both registers the selectors with the right types, and
+	 it also fixes up the 'struct objc_method' structures inside
+	 the protocol so that each method_name (a char * as compiled
+	 by the compiler) is replaced with the appropriate runtime
+	 SEL.  */
+      if (protocol->class_methods)
+	__objc_register_selectors_from_description_list (protocol->class_methods);
+
+      if (protocol->instance_methods)
+	__objc_register_selectors_from_description_list (protocol->instance_methods);
+
+      /* Register the protocol in the hashtable or protocols by
+	 name.  */
+      __objc_protocols_add_protocol (protocol->protocol_name, protocol);
+      
+      /* Init super protocols.  */
+      __objc_init_protocols (protocol->protocol_list);
+    }
+  else if (protocol->class_pointer != proto_class)
+    {
+      _objc_abort ("Version %d doesn't match runtime protocol version %d\n",
+		   (int) ((char *) protocol->class_pointer
+			  - (char *) 0),
+		   PROTOCOL_VERSION);
+    }
+}
+
+static void
+__objc_init_protocols (struct objc_protocol_list *protos)
+{
+  size_t i;
+  static Class proto_class = 0;
+
+  if (! protos)
+    return;
+
+  objc_mutex_lock (__objc_runtime_mutex);
+
+  if (! proto_class)
+    proto_class = objc_getClass ("Protocol");
+
+  if (! proto_class)
+    {
+      unclaimed_proto_list = list_cons (protos, unclaimed_proto_list);
+      objc_mutex_unlock (__objc_runtime_mutex);
+      return;
+    }
+
+#if 0
+  assert (protos->next == 0); /* Only single ones allowed.  */
+#endif
+
+  for (i = 0; i < protos->count; i++)
+    {
+      struct objc_protocol *aProto = protos->list[i];
+      __objc_init_protocol (aProto);
+    }
+
+  objc_mutex_unlock (__objc_runtime_mutex);
+}
+
+static void
+__objc_class_add_protocols (Class class, struct objc_protocol_list *protos)
+{
+  if (! protos)
+    return;
+
+  protos->next = class->protocols;
+  class->protocols = protos;
+}