libstdc++-v3/libsupc++/atexit_thread.cc

   1 // Copyright (C) 2012-2021 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 #ifdef _GLIBCXX_THREAD_ATEXIT_WIN32
  29 #define WIN32_LEAN_AND_MEAN
  30 #include <windows.h>
  31 #endif
  32
  33 // Simplify it a little for this file.
  34 #ifndef _GLIBCXX_CDTOR_CALLABI
  35 #  define _GLIBCXX_CDTOR_CALLABI
  36 #endif
  37
  38 #if _GLIBCXX_HAVE___CXA_THREAD_ATEXIT
  39
  40 // Libc provides __cxa_thread_atexit definition.
  41
  42 #elif _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL
  43
  44 extern "C" int __cxa_thread_atexit_impl (void (_GLIBCXX_CDTOR_CALLABI *func) (void *),
  45                                          void *arg, void *d);
  46 extern "C" int
  47 __cxxabiv1::__cxa_thread_atexit (void (_GLIBCXX_CDTOR_CALLABI *dtor)(void *),
  48                                  void *obj, void *dso_handle)
  49   _GLIBCXX_NOTHROW
  50 {
  51   return __cxa_thread_atexit_impl (dtor, obj, dso_handle);
  52 }
  53
  54 #else /* _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */
  55
  56 namespace {
  57   // One element in a singly-linked stack of cleanups.
  58   struct elt
  59   {
  60     void (_GLIBCXX_CDTOR_CALLABI *destructor)(void *);
  61     void *object;
  62     elt *next;
  63 #ifdef _GLIBCXX_THREAD_ATEXIT_WIN32
  64     HMODULE dll;
  65 #endif
  66   };
  67
  68   // Keep a per-thread list of cleanups in gthread_key storage.
  69   __gthread_key_t key;
  70   // But also support non-threaded mode.
  71   elt *single_thread;
  72
  73   // Run the specified stack of cleanups.
  74   void run (void *p)
  75   {
  76     elt *e = static_cast<elt*>(p);
  77     while (e)
  78       {
  79         elt *old_e = e;
  80         e->destructor (e->object);
  81 #ifdef _GLIBCXX_THREAD_ATEXIT_WIN32
  82         /* Decrement DLL count */
  83         if (e->dll)
  84           FreeLibrary (e->dll);
  85 #endif
  86         e = e->next;
  87         delete (old_e);
  88       }
  89   }
  90
  91   // Run the stack of cleanups for the current thread.
  92   void run ()
  93   {
  94     void *e;
  95     if (__gthread_active_p ())
  96       {
  97         e = __gthread_getspecific (key);
  98         __gthread_setspecific (key, NULL);
  99       }
 100     else
 101       {
 102         e = single_thread;
 103         single_thread = NULL;
 104       }
 105     run (e);
 106   }
 107
 108   // Initialize the key for the cleanup stack.  We use a static local for
 109   // key init/delete rather than atexit so that delete is run on dlclose.
 110   void key_init() {
 111     struct key_s {
 112       key_s() { __gthread_key_create (&key, run); }
 113       ~key_s() { __gthread_key_delete (key); }
 114     };
 115     static key_s ks;
 116     // Also make sure the destructors are run by std::exit.
 117     // FIXME TLS cleanups should run before static cleanups and atexit
 118     // cleanups.
 119     std::atexit (run);
 120   }
 121 }
 122
 123 extern "C" int
 124 __cxxabiv1::__cxa_thread_atexit (void (_GLIBCXX_CDTOR_CALLABI *dtor)(void *),
 125                                  void *obj, void */*dso_handle*/)
 126   _GLIBCXX_NOTHROW
 127 {
 128   // Do this initialization once.
 129   if (__gthread_active_p ())
 130     {
 131       // When threads are active use __gthread_once.
 132       static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 133       __gthread_once (&once, key_init);
 134     }
 135   else
 136     {
 137       // And when threads aren't active use a static local guard.
 138       static bool queued;
 139       if (!queued)
 140         {
 141           queued = true;
 142           std::atexit (run);
 143         }
 144     }
 145
 146   elt *first;
 147   if (__gthread_active_p ())
 148     first = static_cast<elt*>(__gthread_getspecific (key));
 149   else
 150     first = single_thread;
 151
 152   elt *new_elt = new (std::nothrow) elt;
 153   if (!new_elt)
 154     return -1;
 155   new_elt->destructor = dtor;
 156   new_elt->object = obj;
 157   new_elt->next = first;
 158 #ifdef _GLIBCXX_THREAD_ATEXIT_WIN32
 159   /* Store the DLL address for a later call to FreeLibrary in new_elt and
 160      increment DLL load count.  This blocks the unloading of the DLL
 161      before the thread-local dtors have been called.  This does NOT help
 162      if FreeLibrary/dlclose is called in excess. */
 163   GetModuleHandleExW (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 164                       (LPCWSTR) dtor, &new_elt->dll);
 165 #endif
 166
 167   if (__gthread_active_p ())
 168     __gthread_setspecific (key, new_elt);
 169   else
 170     single_thread = new_elt;
 171
 172   return 0;
 173 }
 174
 175 #endif /* _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */