1 // Copyright (C) 2012-2022 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 */ 176