[multiple changes]

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.

From-SVN: r112361

7 files changed, 581 insertions, 137 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e47ecd1..cdb1fdc 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2006-03-24  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.
+
 2006-03-24  Carlos O'Donell  <carlos@codesourcery.com>
 
 	* doc/invoke.texi: Document -femit-class-debug-always
diff --git a/gcc/config/darwin-crt3.c b/gcc/config/darwin-crt3.c
index 698b375..1cbb4b5 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);
 }
diff --git a/gcc/config/darwin.h b/gcc/config/darwin.h
index 8b836f8..eef5e45 100644
--- a/gcc/config/darwin.h
+++ b/gcc/config/darwin.h
@@ -341,7 +341,7 @@ Boston, MA 02110-1301, USA.  */
                       %{!static:%{object:-lcrt0.o}			    \
                                 %{!object:%{preload:-lcrt0.o}		    \
                                   %{!preload:-lcrt1.o %(darwin_crt2)}}}}}}  \
-  %{shared-libgcc:%:version-compare(< 10.5 mmacosx-version-min= -lcrt3.o)}"
+  %{shared-libgcc:%:version-compare(< 10.5 mmacosx-version-min= crt3.o%s)}"
 
 /* The native Darwin linker doesn't necessarily place files in the order
    that they're specified on the link line.  Thus, it is pointless
diff --git a/gcc/config/t-darwin b/gcc/config/t-darwin
index 5995f30..b6ee9c0 100644
--- a/gcc/config/t-darwin
+++ b/gcc/config/t-darwin
@@ -14,9 +14,11 @@ gt-darwin.h : s-gtype ; @true
 
 # How to build crt3.o
 EXTRA_MULTILIB_PARTS=crt3.o
+# Pass -fno-tree-dominator-opts to work around bug 26840.
 $(T)crt3$(objext): $(srcdir)/config/darwin-crt3.c $(GCC_PASSES) \
 	$(TCONFIG_H) stmp-int-hdrs tsystem.h
 	$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(INCLUDES) $(MULTILIB_CFLAGS) \
+	  -fno-tree-dominator-opts \
 	  -c $(srcdir)/config/darwin-crt3.c -o $(T)crt3$(objext)
 
 # Use unwind-dw2-fde-darwin
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index ccfb5df..5b1894c 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -5326,8 +5326,9 @@ is_c_family (void)
 {
   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
 
-  return (lang == DW_LANG_C || lang == DW_LANG_C89
-	  || lang == DW_LANG_C_plus_plus);
+  return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
+	  || lang == DW_LANG_C99
+	  || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
 }
 
 /* Return TRUE if the language is C++.  */
@@ -5335,8 +5336,9 @@ is_c_family (void)
 static inline bool
 is_cxx (void)
 {
-  return (get_AT_unsigned (comp_unit_die, DW_AT_language)
-	  == DW_LANG_C_plus_plus);
+  unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
+  
+  return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
 }
 
 /* Return TRUE if the language is Fortran.  */
@@ -9927,6 +9929,23 @@ add_const_value_attribute (dw_die_ref die, rtx rtl)
 
 }
 
+/* Determine whether the evaluation of EXPR references any variables
+   or functions which aren't otherwise used (and therefore may not be
+   output).  */
+static tree
+reference_to_unused (tree * tp, int * walk_subtrees,
+		     void * data ATTRIBUTE_UNUSED)
+{
+  if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
+    *walk_subtrees = 0;
+  
+  if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
+      && ! TREE_ASM_WRITTEN (*tp))
+    return *tp;
+  else
+    return NULL_TREE;
+}
+
 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
    for use in a later add_const_value_attribute call.  */
 
@@ -9953,15 +9972,16 @@ rtl_for_decl_init (tree init, tree type)
 	rtl = gen_rtx_CONST_STRING (VOIDmode,
 				    ggc_strdup (TREE_STRING_POINTER (init)));
     }
+  /* Although DWARF could easily handle other kinds of aggregates, we
+     have no way to represent such values as RTL constants, so skip
+     those.  */
+  else if (AGGREGATE_TYPE_P (type))
+    ;
   /* If the initializer is something that we know will expand into an
-     immediate RTL constant, expand it now.  Expanding anything else
-     tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
-  /* Aggregate, vector, and complex types may contain constructors that may
-     result in code being generated when expand_expr is called, so we can't
-     handle them here.  Integer and float are useful and safe types to handle
-     here.  */
-  else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
-	   && initializer_constant_valid_p (init, type) == null_pointer_node)
+     immediate RTL constant, expand it now.  We must be careful not to
+     reference variables which won't be output.  */
+  else if (initializer_constant_valid_p (init, type)
+	   && ! walk_tree (&init, reference_to_unused, NULL, NULL))
     {
       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
 
@@ -10325,6 +10345,9 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl,
       add_AT_location_description (die, attr, descr);
       return;
     }
+  /* None of that worked, so it must not really have a location;
+     try adding a constant value attribute from the DECL_INITIAL.  */
+  tree_add_const_value_attribute (die, decl);
 }
 
 /* If we don't have a copy of this variable in memory for some reason (such
@@ -12204,6 +12227,10 @@ gen_compile_unit_die (const char *filename)
     language = DW_LANG_Pascal83;
   else if (strcmp (language_string, "GNU Java") == 0)
     language = DW_LANG_Java;
+  else if (strcmp (language_string, "GNU Objective-C") == 0)
+    language = DW_LANG_ObjC;
+  else if (strcmp (language_string, "GNU Objective-C++") == 0)
+    language = DW_LANG_ObjC_plus_plus;
   else
     language = DW_LANG_C89;
 
@@ -13314,8 +13341,7 @@ dwarf2out_decl (tree decl)
 	{
 	  /* OK, we need to generate one for `bool' so GDB knows what type
 	     comparisons have.  */
-	  if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
-	       == DW_LANG_C_plus_plus)
+	  if (is_cxx ()
 	      && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
 	      && ! DECL_IGNORED_P (decl))
 	    modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 197f6c3..6857ace 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2006-03-24  Geoffrey Keating  <geoffk@apple.com>
+
+	* g++.old-deja/g++.other/init19.C: New.
+
 2006-03-24  David Edelsohn  <edelsohn@gnu.org>
 
 	* g++.dg/eh/spbp.C: Skip on AIX.
diff --git a/gcc/testsuite/g++.old-deja/g++.other/init19.C b/gcc/testsuite/g++.old-deja/g++.other/init19.C
new file mode 100644
index 0000000..297ae78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/init19.C
@@ -0,0 +1,85 @@
+// { dg-do run }
+#include <stdlib.h>
+
+#define assert(x) do { if (! (x)) abort(); } while (0)
+
+int count = 0;
+
+class A
+{
+public:
+	explicit A(int i);
+	~A();
+
+	int i;
+
+	A(const A&);
+	A& operator=(const A&);
+};
+
+A::A(int i_)
+	: i(i_)
+{
+}
+
+A::~A()
+{
+	assert(++count == i);
+	i = -1;
+}
+
+extern "C" {
+
+void one()
+{
+	static bool second_time;
+	if (second_time)
+		assert(++count == 9);
+	else
+	{
+		assert(++count == 1);
+		second_time = true;
+	}
+	static A a(10);
+	assert(a.i == 10);
+}
+
+void two()
+{
+	assert(++count == 7);
+	static A a(8);
+	assert(a.i == 8);
+}
+
+void three()
+{
+	assert(++count == 2);
+	static A a(6);
+	assert(a.i == 6);
+}
+
+void five()
+{
+	assert(++count == 4);
+	static A a(5);
+	assert(a.i == 5);
+}
+
+void four()
+{
+	assert(++count == 3);
+	atexit(five);
+}
+
+}
+
+A zero(11);
+
+int main()
+{
+	one();
+	atexit(one);
+	atexit(two);
+	three();
+	atexit(four);
+}