1/**
  2 * This file has no copyright assigned and is placed in the Public Domain.
  3 * This file is part of the mingw-w64 runtime package.
  4 * No warranty is given; refer to the file DISCLAIMER.PD within this package.
  5 */
  6
  7#include <sect_attribs.h>
  8
  9#ifndef WIN32_LEAN_AND_MEAN
 10#define WIN32_LEAN_AND_MEAN
 11#endif
 12#include <windows.h>
 13
 14#include <assert.h>
 15#include <stdio.h>
 16#include <stdlib.h>
 17#include <corecrt_startup.h>
 18#include <process.h>
 19
 20
 21typedef void (__thiscall * dtor_fn)(void*);
 22int __mingw_cxa_atexit(dtor_fn dtor, void *obj, void *dso);
 23int __mingw_cxa_thread_atexit(dtor_fn dtor, void *obj, void *dso);
 24
 25typedef struct dtor_obj dtor_obj;
 26struct dtor_obj {
 27  dtor_fn dtor;
 28  void *obj;
 29  dtor_obj *next;
 30};
 31
 32HANDLE __dso_handle;
 33extern char __mingw_module_is_dll;
 34
 35static CRITICAL_SECTION lock;
 36static int inited = 0;
 37static dtor_obj *global_dtors = NULL;
 38static DWORD tls_dtors_slot = TLS_OUT_OF_INDEXES;
 39
 40int __mingw_cxa_atexit(dtor_fn dtor, void *obj, void *dso) {
 41  if (!inited)
 42    return 1;
 43  assert(!dso || dso == &__dso_handle);
 44  dtor_obj *handler = (dtor_obj *) calloc(1, sizeof(*handler));
 45  if (!handler)
 46    return 1;
 47  handler->dtor = dtor;
 48  handler->obj = obj;
 49  EnterCriticalSection(&lock);
 50  handler->next = global_dtors;
 51  global_dtors = handler;
 52  LeaveCriticalSection(&lock);
 53  return 0;
 54}
 55
 56static void run_dtor_list(dtor_obj **ptr) {
 57  if (!ptr)
 58    return;
 59  while (*ptr) {
 60    dtor_obj *cur = *ptr;
 61    *ptr = cur->next;
 62    cur->dtor(cur->obj);
 63    free(cur);
 64  }
 65}
 66
 67int __mingw_cxa_thread_atexit(dtor_fn dtor, void *obj, void *dso) {
 68  if (!inited)
 69    return 1;
 70  assert(!dso || dso == &__dso_handle);
 71
 72  dtor_obj **head = (dtor_obj **)TlsGetValue(tls_dtors_slot);
 73  if (!head) {
 74    head = (dtor_obj **) calloc(1, sizeof(*head));
 75    if (!head)
 76      return 1;
 77    TlsSetValue(tls_dtors_slot, head);
 78  }
 79  dtor_obj *handler = (dtor_obj *) calloc(1, sizeof(*handler));
 80  if (!handler)
 81    return 1;
 82  handler->dtor = dtor;
 83  handler->obj = obj;
 84  handler->next = *head;
 85  *head = handler;
 86  return 0;
 87}
 88
 89static void WINAPI tls_atexit_callback(HANDLE __UNUSED_PARAM(hDllHandle), DWORD dwReason, LPVOID __UNUSED_PARAM(lpReserved)) {
 90  if (dwReason == DLL_PROCESS_DETACH) {
 91    dtor_obj **p = (dtor_obj **)TlsGetValue(tls_dtors_slot);
 92    run_dtor_list(p);
 93    free(p);
 94    TlsSetValue(tls_dtors_slot, NULL);
 95    TlsFree(tls_dtors_slot);
 96    run_dtor_list(&global_dtors);
 97  }
 98}
 99
100static void WINAPI tls_callback(HANDLE hDllHandle, DWORD dwReason, LPVOID __UNUSED_PARAM(lpReserved)) {
101  dtor_obj **p;
102  switch (dwReason) {
103  case DLL_PROCESS_ATTACH:
104    if (inited == 0) {
105      InitializeCriticalSection(&lock);
106      __dso_handle = hDllHandle;
107      tls_dtors_slot = TlsAlloc();
108      /*
109       * We can only call _register_thread_local_exe_atexit_callback once
110       * in a process; if we call it a second time the process terminates.
111       * When DLLs are unloaded, this callback is invoked before we run the
112       * _onexit tables, but for exes, we need to ask this to be called before
113       * all other registered atexit functions.
114       * Since we are registered as a normal TLS callback, we will be called
115       * another time later as well, but that doesn't matter, it's safe to
116       * invoke this with DLL_PROCESS_DETACH twice.
117       */
118      if (!__mingw_module_is_dll)
119        _register_thread_local_exe_atexit_callback(tls_atexit_callback);
120    }
121    inited = 1;
122    break;
123  case DLL_PROCESS_DETACH:
124    /*
125     * If there are other threads still running that haven't been detached,
126     * we don't attempt to run their destructors (MSVC doesn't either), but
127     * simply leak the destructor list and whatever resources the destructors
128     * would have released.
129     *
130     * From Vista onwards, we could have used FlsAlloc to get a TLS key that
131     * runs a destructor on each thread that has a value attached ot it, but
132     * since MSVC doesn't run destructors on other threads in this case,
133     * users shouldn't assume it and we don't attempt to do anything potentially
134     * risky about it. TL;DR, threads with pending TLS destructors for a DLL
135     * need to be joined before unloading the DLL.
136     *
137     * This gets called both when exiting cleanly (via exit or returning from
138     * main, or when a DLL is unloaded), and when exiting bypassing some of
139     * the cleanup, by calling _exit or ExitProcess. In the latter cases,
140     * destructors (both TLS and global) in loaded DLLs still get called,
141     * but none get called for the main executable. This matches what the
142     * standard says, but differs from what MSVC does with a dynamically
143     * linked CRT (which still runs TLS destructors for the main thread).
144     */
145    if (__mingw_module_is_dll) {
146      p = (dtor_obj **)TlsGetValue(tls_dtors_slot);
147      run_dtor_list(p);
148      free(p);
149      TlsSetValue(tls_dtors_slot, NULL);
150      /* For DLLs, run dtors when detached. For EXEs, run dtors via the
151       * thread local atexit callback, to make sure they don't run when
152       * exiting the process with _exit or ExitProcess. */
153      run_dtor_list(&global_dtors);
154      TlsFree(tls_dtors_slot);
155    }
156    if (inited == 1) {
157      inited = 0;
158      DeleteCriticalSection(&lock);
159    }
160    break;
161  case DLL_THREAD_ATTACH:
162    break;
163  case DLL_THREAD_DETACH:
164    p = (dtor_obj **)TlsGetValue(tls_dtors_slot);
165    run_dtor_list(p);
166    free(p);
167    TlsSetValue(tls_dtors_slot, NULL);
168    break;
169  }
170}
171
172_CRTALLOC(".CRT$XLB") PIMAGE_TLS_CALLBACK __xl_b = tls_callback;