2006-03-23 Geoffrey Keating <geoffk@apple.com>

	PR 26793
	* config/t-darwin (crt3.o): Work around bug 26840.
	* config/darwin-crt3.c: Rewrite.
	* config/darwin.h (STARTFILE_SPEC): Don't use -l for crt3.o.

Index: gcc/testsuite/ChangeLog
2006-03-24  Geoffrey Keating  <geoffk@apple.com>

	* g++.old-deja/g++.other/init19.C: New.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@112361 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 442 insertions, 122 deletions

diff --git a/gcc/config/darwin-crt3.c b/gcc/config/darwin-crt3.c
index 698b375c69c..1cbb4b5fc2d 100644
--- a/gcc/config/darwin-crt3.c
+++ b/gcc/config/darwin-crt3.c
@@ -37,172 +37,492 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include <dlfcn.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* This file works around two different problems.
 
    The first problem is that there is no __cxa_atexit on Mac OS versions
-   before 10.4.  It fixes this by providing one, and having it called from
-   a destructor.  This is not quite as good as having a real __cxa_atexit,
-   but it's good enough to imitate the behaviour that you'd get if
-   you didn't have one.
+   before 10.4.  It fixes this by providing a complete atexit and
+   __cxa_atexit emulation called from the regular atexit.
 
-   The second problem is that on 10.4 Mac OS versions, __cxa_finalize
-   doesn't work right: it doesn't run routines that were registered
-   while other atexit routines are running.  This is worked around by
-   installing our own handler so that it runs last, and repeatedly
-   running __cxa_finalize until no new calls to __cxa_atexit are made.  */
+   The second problem is that on all shipping versions of Mac OS,
+   __cxa_finalize and exit() don't work right: they don't run routines
+   that were registered while other atexit routines are running.  This
+   is worked around by wrapping each atexit/__cxa_atexit routine with
+   our own routine which ensures that any __cxa_atexit calls while it
+   is running are honoured.
 
-typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, void* dso);
+   There are still problems which this does not solve.  Before 10.4,
+   shared objects linked with previous compilers won't have their
+   atexit calls properly interleaved with code compiled with newer
+   compilers.  Also, atexit routines registered from shared objects
+   linked with previous compilers won't get the bug fix.  */
+
+typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, const void* dso);
+typedef void (*cxa_finalize_p)(const void *dso);
+typedef int (*atexit_p)(void (*func)(void));
+
+/* These are from "keymgr.h".  */
+extern void *_keymgr_get_and_lock_processwide_ptr (unsigned key);
+extern int _keymgr_get_and_lock_processwide_ptr_2 (unsigned, void **);
+extern int _keymgr_set_and_unlock_processwide_ptr (unsigned key, void *ptr);
+
+extern void *__keymgr_global[];
+typedef struct _Sinfo_Node {
+        unsigned int size ;             /*size of this node*/
+        unsigned short major_version ;  /*API major version.*/
+        unsigned short minor_version ;  /*API minor version.*/
+        } _Tinfo_Node ;
 
 #ifdef __ppc__
-void __cxa_finalize (void* dso) __attribute__((weak));
+#define CHECK_KEYMGR_ERROR(e) \
+  (((_Tinfo_Node *)__keymgr_global[2])->major_version >= 4 ? (e) : 0)
 #else
-void __cxa_finalize (void* dso);
+#define CHECK_KEYMGR_ERROR(e) (e)
 #endif
 
-/* new_atexit_routines is set if __cxa_finalize exists in the system C
-   library and our copy of __cxa_atexit has been called.  */
+/* Our globals are stored under this keymgr index.  */
+#define KEYMGR_ATEXIT_LIST	14
 
-static bool new_atexit_routines;
+/* The different kinds of callback routines.  */
+typedef void (*atexit_callback)(void);
+typedef void (*cxa_atexit_callback)(void *);
 
-/* first_atexit_handler is called after all other atexit routines
-   that were registered before __cxa_finalize is called.
-   It may be called more than once, but is not re-entered.  */
+/* This structure holds a routine to call.  There may be extra fields
+   at the end of the structure that this code doesn't know about.  */
+struct one_atexit_routine 
+{
+  union {
+    atexit_callback ac;
+    cxa_atexit_callback cac;
+  } callback;
+  /* has_arg is 0/2/4 if 'ac' is live, 1/3/5 if 'cac' is live.  
+     Higher numbers indicate a later version of the structure that this
+     code doesn't understand and will ignore.  */
+  int has_arg;
+  void * arg;
+};
 
-static void
-first_atexit_handler(void* dso)
-{
-  /* Keep running __cxa_finalize until no new atexit routines are
-     registered.  
-     Note that this means __cxa_finalize will be called at least twice,
-     even if the first call didn't register any new routines.  */
-  while (new_atexit_routines) {
-    new_atexit_routines = false;
-    __cxa_finalize (dso);
-  };
+struct atexit_routine_list
+{
+  struct atexit_routine_list * next;
+  struct one_atexit_routine r;
+};
+
+/* The various possibilities for status of atexit().  */
+enum atexit_status {
+  atexit_status_unknown = 0,
+  atexit_status_missing = 1,
+  atexit_status_broken = 2,
+  atexit_status_working = 16
+};
+
+struct keymgr_atexit_list
+{
+  /* Version of this list.  This code knows only about version 0.
+     If the version is higher than 0, this code may add new atexit routines
+     but should not attempt to run the list.  */
+  short version;
+  /* 1 if an atexit routine is currently being run by this code, 0
+     otherwise.  */
+  char running_routines;
+  /* Holds a value from 'enum atexit_status'.  */
+  unsigned char atexit_status;
+  /* The list of atexit and cxa_atexit routines registered.  If
+   atexit_status_missing it contains all routines registered while
+   linked with this code.  If atexit_status_broken it contains all
+   routines registered during cxa_finalize while linked with this
+   code.  */
+  struct atexit_routine_list *l;
+  /* &__cxa_atexit; set if atexit_status >= atexit_status_broken.  */
+  cxa_atexit_p cxa_atexit_f;
+  /* &__cxa_finalize; set if atexit_status >= atexit_status_broken.  */
+  cxa_finalize_p cxa_finalize_f;
+  /* &atexit; set if atexit_status >= atexit_status_working
+     or atexit_status == atexit_status_missing.  */
+  atexit_p atexit_f;
+};
+
+/* Return 0 if __cxa_atexit has the bug it has in Mac OS 10.4: it
+   fails to call routines registered while an atexit routine is
+   running.  Return 1 if it works properly, and -1 if an error occurred.  */
+
+struct atexit_data 
+{
+  int result;
+  cxa_atexit_p cxa_atexit;
+};
+
+static void cxa_atexit_check_2 (void *arg)
+{
+  ((struct atexit_data *)arg)->result = 1;
 }
 
-/* This is our wrapper around __cxa_atexit that's called if __cxa_finalize
-   exists in the system library.  All it does is, on its first call,
-   install first_atexit_handler; and on every call, set new_atexit_routines
-   and pass control to the system __cxa_atexit.
-   This proves to be somewhat more complicated than you might expect,
-   because it may be called in a multithreaded environment.  Fortunately
-   it turns out to be possible to do what's needed without resorting
-   to locking.  */
+static void cxa_atexit_check_1 (void *arg)
+{
+  struct atexit_data * aed = arg;
+  if (aed->cxa_atexit (cxa_atexit_check_2, arg, arg) != 0)
+    aed->result = -1;
+}
 
 static int
-cxa_atexit_wrapper (void (*func) (void*), void* arg, void* dso)
+check_cxa_atexit (cxa_atexit_p cxa_atexit, cxa_finalize_p cxa_finalize)
 {
-  static volatile cxa_atexit_p real_cxa_atexit;
-  cxa_atexit_p auto_cxa_atexit = real_cxa_atexit;
-  if (! auto_cxa_atexit)
+  struct atexit_data aed = { 0, cxa_atexit };
+
+  /* We re-use &aed as the 'dso' parameter, since it's a unique address.  */
+  if (cxa_atexit (cxa_atexit_check_1, &aed, &aed) != 0)
+    return -1;
+  cxa_finalize (&aed);
+  if (aed.result == 0)
     {
-      void* handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
-      if (! handle)
-	return -1;
-      
-      auto_cxa_atexit = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
-      if (! auto_cxa_atexit)
-	return -1;
+      /* Call __cxa_finalize again to make sure that cxa_atexit_check_2
+	 is removed from the list before AED goes out of scope.  */
+      cxa_finalize (&aed);
+      aed.result = 0;
     }
-  /* At this point, auto_cxa_atexit contains the address of
-     the system __cxa_atexit.  */
-  if (! real_cxa_atexit)
+  return aed.result;
+}
+
+#ifdef __ppc__
+/* This comes from Csu.  It works only before 10.4.  The prototype has
+   been altered a bit to avoid casting.  */
+extern int _dyld_func_lookup(const char *dyld_func_name,
+     void *address) __attribute__((visibility("hidden")));
+
+static void our_atexit (void);
+
+/* We're running on 10.3.9.  Find the address of the system atexit()
+   function.  So easy to say, so hard to do.  */
+static atexit_p
+find_atexit_10_3 (void)
+{
+  unsigned int (*dyld_image_count_fn)(void);
+  const char *(*dyld_get_image_name_fn)(unsigned int image_index);
+  const void *(*dyld_get_image_header_fn)(unsigned int image_index);
+  const void *(*NSLookupSymbolInImage_fn)(const void *image, 
+					  const char *symbolName,
+					  unsigned int options);
+  void *(*NSAddressOfSymbol_fn)(const void *symbol);
+  unsigned i, count;
+  
+  /* Find some dyld functions.  */
+  _dyld_func_lookup("__dyld_image_count", &dyld_image_count_fn);
+  _dyld_func_lookup("__dyld_get_image_name", &dyld_get_image_name_fn);
+  _dyld_func_lookup("__dyld_get_image_header", &dyld_get_image_header_fn);
+  _dyld_func_lookup("__dyld_NSLookupSymbolInImage", &NSLookupSymbolInImage_fn);
+  _dyld_func_lookup("__dyld_NSAddressOfSymbol", &NSAddressOfSymbol_fn);
+
+  /* If any of these don't exist, that's an error.  */
+  if (! dyld_image_count_fn || ! dyld_get_image_name_fn
+      || ! dyld_get_image_header_fn || ! NSLookupSymbolInImage_fn
+      || ! NSAddressOfSymbol_fn)
+    return NULL;
+  
+  count = dyld_image_count_fn ();
+  for (i = 0; i < count; i++)
     {
-      /* Install our handler above before any other handlers
-	 for this image, so it will be called last.  */
-      int result = (*auto_cxa_atexit)(first_atexit_handler, dso, dso);
-      if (result != 0)
-	return result;
-      /* Now set the global real_cxa_atexit to prevent further
-	 installations of first_atexit_handler.  Do this after
-	 the installation so that if another thread sees it is set,
-	 it can be sure that first_atexit_handler really has been
-	 installed.  */
-      real_cxa_atexit = auto_cxa_atexit;
+      const char * path = dyld_get_image_name_fn (i);
+      const void * image;
+      const void * symbol;
+      
+      if (strcmp (path, "/usr/lib/libSystem.B.dylib") != 0)
+	continue;
+      image = dyld_get_image_header_fn (i);
+      if (! image)
+	return NULL;
+      /* '4' is NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR.  */
+      symbol = NSLookupSymbolInImage_fn (image, "_atexit", 4);
+      if (! symbol)
+	return NULL;
+      return NSAddressOfSymbol_fn (symbol);
     }
-  /* At this point, we know that first_atexit_handler has been
-     installed at least once, and real_cxa_atexit is not NULL.  */
-  /* It's not necessary to mark new_atexit_routines as volatile, so long
-     as this write eventually happens before this shared object is
-     unloaded.  */
-  new_atexit_routines = true;
-  /* Call the original __cxa_atexit for this function.  */
-  return (*auto_cxa_atexit)(func, arg, dso);
+  return NULL;
 }
-
-#ifdef __ppc__
-/* This code is used while running on 10.3.9, when __cxa_atexit doesn't
-   exist in the system library.  10.3.9 only supported regular PowerPC,
-   so this code isn't necessary on x86 or ppc64.  */
+#endif
 
-/* This structure holds a routine to call.  */
-struct atexit_routine
+/* Create (if necessary), find, lock, fill in, and return our globals.  
+   Return NULL on error, in which case the globals will not be locked.  
+   The caller should call keymgr_set_and_unlock.  */
+static struct keymgr_atexit_list *
+get_globals (void)
 {
-  struct atexit_routine * next;
-  void (*func)(void *);
-  void * arg;
-};
+  struct keymgr_atexit_list * r;
+  
+#ifdef __ppc__
+  /* 10.3.9 doesn't have _keymgr_get_and_lock_processwide_ptr_2 so the
+     PPC side can't use it.  On 10.4 this just means the error gets
+     reported a little later when
+     _keymgr_set_and_unlock_processwide_ptr finds that the key was
+     never locked.  */
+  r = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+#else
+  void * rr;
+  if (_keymgr_get_and_lock_processwide_ptr_2 (KEYMGR_ATEXIT_LIST, &rr))
+    return NULL;
+  r = rr;
+#endif
+  
+  if (r == NULL)
+    {
+      r = calloc (sizeof (struct keymgr_atexit_list), 1);
+      if (! r)
+	return NULL;
+    }
+
+  if (r->atexit_status == atexit_status_unknown)
+    {
+      void *handle;
+
+      handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
+      if (!handle)
+	{
+#ifdef __ppc__
+	  r->atexit_status = atexit_status_missing;
+	  r->atexit_f = find_atexit_10_3 ();
+	  if (! r->atexit_f)
+	    goto error;
+	  if (r->atexit_f (our_atexit))
+	    goto error;
+#else
+	  goto error;
+#endif
+	}
+      else
+	{
+	  int chk_result;
+
+	  r->cxa_atexit_f = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
+	  r->cxa_finalize_f = (cxa_finalize_p)dlsym (handle, "__cxa_finalize");
+	  if (! r->cxa_atexit_f || ! r->cxa_finalize_f)
+	    goto error;
 
-static struct atexit_routine * volatile atexit_routines_list;
+	  chk_result = check_cxa_atexit (r->cxa_atexit_f, r->cxa_finalize_f);
+	  if (chk_result == -1)
+	    goto error;
+	  else if (chk_result == 0)
+	    r->atexit_status = atexit_status_broken;
+	  else
+	    {
+	      r->atexit_f = (atexit_p)dlsym (handle, "atexit");
+	      if (! r->atexit_f)
+		goto error;
+	      r->atexit_status = atexit_status_working;
+	    }
+	}
+    }
 
-/* If __cxa_atexit doesn't exist at all in the system library, this
-   routine is used; it completely emulates __cxa_atexit.  
+  return r;
+  
+ error:
+  _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, r);
+  return NULL;
+}
 
-   This routine has to be thread-safe, but fortunately this just means
-   that it has to do atomic list insertion.  */
+/* Add TO_ADD to ATEXIT_LIST.  ATEXIT_LIST may be NULL but is
+   always the result of calling _keymgr_get_and_lock_processwide_ptr and
+   so KEYMGR_ATEXIT_LIST is known to be locked; this routine is responsible
+   for unlocking it.  */
 
 static int
-cxa_atexit_substitute (void (*func) (void*), void* arg,
-		       /* The 'dso' value will always be equal to this
-			  object's __dso_handle.  */
-		       void* dso __attribute__((unused)))
+add_routine (struct keymgr_atexit_list * g,
+	     const struct one_atexit_routine * to_add)
 {
-  struct atexit_routine * s = malloc (sizeof (struct atexit_routine));
-  struct atexit_routine * next, * old_next;
+  struct atexit_routine_list * s
+    = malloc (sizeof (struct atexit_routine_list));
+  int result;
+  
   if (!s)
-    return -1;
-  s->func = func;
-  s->arg = arg;
-  next = atexit_routines_list;
-  do {
-    s->next = old_next = next;
-    next = __sync_val_compare_and_swap (&atexit_routines_list, old_next, s);
-  } while (next != old_next);
-  return 0;
+    {
+      _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+      return -1;
+    }
+  s->r = *to_add;
+  s->next = g->l;
+  g->l = s;
+  result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+  return CHECK_KEYMGR_ERROR (result) == 0 ? 0 : -1;
 }
 
-/* The routines added in cxa_atexit_substitute get run here, in a destructor.
-   This routine doesn't have to be thread-safe.  */
+/* This runs the routines in G->L up to STOP.  */
+static struct keymgr_atexit_list *
+run_routines (struct keymgr_atexit_list *g,
+	      struct atexit_routine_list *stop)
+{
+  for (;;)
+    {
+      struct atexit_routine_list * cur = g->l;
+      if (! cur || cur == stop)
+	break;
+      g->l = cur->next;
+      _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+
+      switch (cur->r.has_arg) {
+      case 0: case 2: case 4:
+	cur->r.callback.ac ();
+	break;
+      case 1: case 3: case 5:
+	cur->r.callback.cac (cur->r.arg);
+	break;
+      default:
+	/* Don't understand, so don't call it.  */
+	break;
+      }
+      free (cur);
+
+      g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+      if (! g)
+	break;
+    }
+  return g;
+}
+
+/* Call the routine described by ROUTINE_PARAM and then call any
+   routines added to KEYMGR_ATEXIT_LIST while that routine was
+   running, all with in_cxa_finalize set.  */
 
-static void cxa_dtor (void) __attribute__((destructor));
 static void
-cxa_dtor (void)
+cxa_atexit_wrapper (void* routine_param)
 {
-  while (atexit_routines_list)
+  struct one_atexit_routine * routine = routine_param;
+  struct keymgr_atexit_list *g;
+  struct atexit_routine_list * base = NULL;
+  char prev_running = 0;
+  
+  g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+  if (g)
     {
-      struct atexit_routine * working_list = atexit_routines_list;
-      atexit_routines_list = NULL;
-      while (working_list)
+      prev_running = g->running_routines;
+      g->running_routines = 1;
+      base = g->l;
+      _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+    }
+
+  if (routine->has_arg)
+    routine->callback.cac (routine->arg);
+  else
+    routine->callback.ac ();
+
+  if (g)
+    g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+  if (g)
+    g = run_routines (g, base);
+  if (g)
+    {
+      g->running_routines = prev_running;
+      _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+    }
+}
+
+#ifdef __ppc__
+/* This code is used while running on 10.3.9, when __cxa_atexit doesn't
+   exist in the system library.  10.3.9 only supported regular PowerPC,
+   so this code isn't necessary on x86 or ppc64.  */
+
+/* This routine is called from the system atexit(); it runs everything
+   registered on the KEYMGR_ATEXIT_LIST.  */
+
+static void
+our_atexit (void)
+{
+  struct keymgr_atexit_list *g;
+  char prev_running;
+
+  g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+  if (! g || g->version != 0 || g->atexit_status != atexit_status_missing)
+    return;
+  
+  prev_running = g->running_routines;
+  g->running_routines = 1;
+  g = run_routines (g, NULL);
+  if (! g)
+    return;
+  g->running_routines = prev_running;
+  _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+}
+#endif
+
+/* This is our wrapper around atexit and __cxa_atexit.  It will return
+   nonzero if an error occurs, and otherwise:
+   - if in_cxa_finalize is set, or running on 10.3.9, add R to
+     KEYMGR_ATEXIT_LIST; or
+   - call the system __cxa_atexit to add cxa_atexit_wrapper with an argument
+     that indicates how cxa_atexit_wrapper should call R.  */
+
+static int
+atexit_common (const struct one_atexit_routine *r, const void *dso)
+{
+  struct keymgr_atexit_list *g = get_globals ();
+
+  if (! g)
+    return -1;
+  
+  if (g->running_routines || g->atexit_status == atexit_status_missing)
+    return add_routine (g, r);
+
+  if (g->atexit_status >= atexit_status_working)
+    {
+      int result;
+      if (r->has_arg)
 	{
-	  struct atexit_routine * called_routine = working_list;
-	  working_list->func (working_list->arg);
-	  working_list = working_list->next;
-	  free (called_routine);
+	  cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
+	  result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
+							   g);
+	  if (CHECK_KEYMGR_ERROR (result))
+	    return -1;
+	  return cxa_atexit (r->callback.cac, r->arg, dso);
 	}
+      else
+	{
+	  atexit_p atexit_f = g->atexit_f;
+	  result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
+							   g);
+	  if (CHECK_KEYMGR_ERROR (result))
+	    return -1;
+	  return atexit_f (r->callback.ac);
+	}
+    }
+  else
+    {
+      cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
+      struct one_atexit_routine *alloced;
+      int result;
+
+      result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+      if (CHECK_KEYMGR_ERROR (result))
+	return -1;
+
+      alloced = malloc (sizeof (struct one_atexit_routine));
+      if (! alloced)
+	return -1;
+      *alloced = *r;
+      return cxa_atexit (cxa_atexit_wrapper, alloced, dso);
     }
 }
-#endif
 
-int __cxa_atexit (void (*func) (void*), void* arg, 
-		  void* dso) __attribute__((visibility("hidden")));
+/* These are the actual replacement routines; they just funnel into
+   atexit_common.  */
+
+int __cxa_atexit (cxa_atexit_callback func, void* arg, 
+		  const void* dso) __attribute__((visibility("hidden")));
+
 int
-__cxa_atexit (void (*func) (void*), void* arg, void* dso)
+__cxa_atexit (cxa_atexit_callback func, void* arg, const void* dso)
 {
-#ifdef __ppc__
-  if (! __cxa_finalize)
-    return cxa_atexit_substitute (func, arg, dso);
-#endif
-  return cxa_atexit_wrapper (func, arg, dso);
+  struct one_atexit_routine r;
+  r.callback.cac = func;
+  r.has_arg = 1;
+  r.arg = arg;
+  return atexit_common (&r, dso);
+}
+
+int atexit (atexit_callback func) __attribute__((visibility("hidden")));
+
+int
+atexit (atexit_callback func)
+{
+  struct one_atexit_routine r;
+  r.callback.ac = func;
+  r.has_arg = 0;
+  return atexit_common (&r, NULL);
 }