l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.8/libsupc++/atexit_thread.cc

   1 // Copyright (C) 2012-2013 Free Software Foundation, Inc.
   2 //
   3 // This file is part of GCC.
   4 //
   5 // GCC is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3, or (at your option)
   8 // any later version.
   9
  10 // GCC is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // Under Section 7 of GPL version 3, you are granted additional
  16 // permissions described in the GCC Runtime Library Exception, version
  17 // 3.1, as published by the Free Software Foundation.
  18
  19 // You should have received a copy of the GNU General Public License and
  20 // a copy of the GCC Runtime Library Exception along with this program;
  21 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 // <http://www.gnu.org/licenses/>.
  23
  24 #include <cxxabi.h>
  25 #include <cstdlib>
  26 #include <new>
  27 #include "bits/gthr.h"
  28
  29 #if HAVE___CXA_THREAD_ATEXIT_IMPL
  30
  31 extern "C" int __cxa_thread_atexit_impl (void (*func) (void *),
  32                                          void *arg, void *d);
  33 extern "C" int
  34 __cxxabiv1::__cxa_thread_atexit (void (*dtor)(void *),
  35                                  void *obj, void *dso_handle)
  36   _GLIBCXX_NOTHROW
  37 {
  38   return __cxa_thread_atexit_impl (dtor, obj, dso_handle);
  39 }
  40
  41 #else /* HAVE___CXA_THREAD_ATEXIT_IMPL */
  42
  43 namespace {
  44   // One element in a singly-linked stack of cleanups.
  45   struct elt
  46   {
  47     void (*destructor)(void *);
  48     void *object;
  49     elt *next;
  50   };
  51
  52   // Keep a per-thread list of cleanups in gthread_key storage.
  53   __gthread_key_t key;
  54   // But also support non-threaded mode.
  55   elt *single_thread;
  56
  57   // Run the specified stack of cleanups.
  58   void run (void *p)
  59   {
  60     elt *e = static_cast<elt*>(p);
  61     for (; e; e = e->next)
  62       e->destructor (e->object);
  63   }
  64
  65   // Run the stack of cleanups for the current thread.
  66   void run ()
  67   {
  68     void *e;
  69     if (__gthread_active_p ())
  70       e = __gthread_getspecific (key);
  71     else
  72       e = single_thread;
  73     run (e);
  74   }
  75
  76   // Initialize the key for the cleanup stack.  We use a static local for
  77   // key init/delete rather than atexit so that delete is run on dlclose.
  78   void key_init() {
  79     struct key_s {
  80       key_s() { __gthread_key_create (&key, run); }
  81       ~key_s() { __gthread_key_delete (key); }
  82     };
  83     static key_s ks;
  84     // Also make sure the destructors are run by std::exit.
  85     // FIXME TLS cleanups should run before static cleanups and atexit
  86     // cleanups.
  87     std::atexit (run);
  88   }
  89 }
  90
  91 extern "C" int
  92 __cxxabiv1::__cxa_thread_atexit (void (*dtor)(void *), void *obj, void */*dso_handle*/)
  93   _GLIBCXX_NOTHROW
  94 {
  95   // Do this initialization once.
  96   if (__gthread_active_p ())
  97     {
  98       // When threads are active use __gthread_once.
  99       static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 100       __gthread_once (&once, key_init);
 101     }
 102   else
 103     {
 104       // And when threads aren't active use a static local guard.
 105       static bool queued;
 106       if (!queued)
 107         {
 108           queued = true;
 109           std::atexit (run);
 110         }
 111     }
 112
 113   elt *first;
 114   if (__gthread_active_p ())
 115     first = static_cast<elt*>(__gthread_getspecific (key));
 116   else
 117     first = single_thread;
 118
 119   elt *new_elt = new (std::nothrow) elt;
 120   if (!new_elt)
 121     return -1;
 122   new_elt->destructor = dtor;
 123   new_elt->object = obj;
 124   new_elt->next = first;
 125
 126   if (__gthread_active_p ())
 127     __gthread_setspecific (key, new_elt);
 128   else
 129     single_thread = new_elt;
 130
 131   return 0;
 132 }
 133
 134 #endif /* HAVE___CXA_THREAD_ATEXIT_IMPL */