newlib-cygwin/newlib/libc/stdlib/__atexit.c

160 lines
4.1 KiB
C

/*
* Common routine to implement atexit-like functionality.
*
* This is also the key function to be configured as lite exit, a size-reduced
* implementation of exit that doesn't invoke clean-up functions such as _fini
* or global destructors.
*
* Default (without lite exit) call graph is like:
* _start -> atexit -> __register_exitproc
* _start -> __libc_init_array -> __cxa_atexit -> __register_exitproc
* on_exit -> __register_exitproc
* _start -> exit -> __call_exitprocs
*
* Here an -> means arrow tail invokes arrow head. All invocations here
* are non-weak reference in current newlib/libgloss.
*
* Lite exit makes some of above calls as weak reference, so that size expansive
* functions __register_exitproc and __call_exitprocs may not be linked. These
* calls are:
* _start w-> atexit
* __cxa_atexit w-> __register_exitproc
* exit w-> __call_exitprocs
*
* Lite exit also makes sure that __call_exitprocs will be referenced as non-weak
* whenever __register_exitproc is referenced as non-weak.
*
* Thus with lite exit libs, a program not explicitly calling atexit or on_exit
* will escape from the burden of cleaning up code. A program with atexit or on_exit
* will work consistently to normal libs.
*
* Lite exit is enabled with --enable-lite-exit, and is controlled with macro
* _LITE_EXIT.
*/
#include <stddef.h>
#include <stdlib.h>
#include <reent.h>
#include <sys/lock.h>
#include "atexit.h"
/* Make this a weak reference to avoid pulling in malloc. */
#ifndef MALLOC_PROVIDED
void * malloc(size_t) _ATTRIBUTE((__weak__));
#endif
#ifdef _LITE_EXIT
/* As __call_exitprocs is weak reference in lite exit, make a
non-weak reference to it here. */
const void * __atexit_dummy = &__call_exitprocs;
#endif
#ifndef __SINGLE_THREAD__
extern _LOCK_RECURSIVE_T __atexit_recursive_mutex;
#endif
#ifdef _REENT_GLOBAL_ATEXIT
static struct _atexit _global_atexit0 = _ATEXIT_INIT;
# define _GLOBAL_ATEXIT0 (&_global_atexit0)
#else
# define _GLOBAL_ATEXIT0 (&_GLOBAL_REENT->_atexit0)
#endif
/*
* Register a function to be performed at exit or on shared library unload.
*/
int
__register_exitproc (int type,
void (*fn) (void),
void *arg,
void *d)
{
struct _on_exit_args * args;
register struct _atexit *p;
#ifndef __SINGLE_THREAD__
__lock_acquire_recursive(__atexit_recursive_mutex);
#endif
p = _GLOBAL_ATEXIT;
if (p == NULL)
{
_GLOBAL_ATEXIT = p = _GLOBAL_ATEXIT0;
#ifdef _REENT_SMALL
extern struct _on_exit_args * const __on_exit_args _ATTRIBUTE ((weak));
if (&__on_exit_args != NULL)
p->_on_exit_args_ptr = __on_exit_args;
#endif /* def _REENT_SMALL */
}
if (p->_ind >= _ATEXIT_SIZE)
{
#if !defined (_ATEXIT_DYNAMIC_ALLOC) || !defined (MALLOC_PROVIDED)
#ifndef __SINGLE_THREAD__
__lock_release_recursive(__atexit_recursive_mutex);
#endif
return -1;
#else
p = (struct _atexit *) malloc (sizeof *p);
if (p == NULL)
{
#ifndef __SINGLE_THREAD__
__lock_release_recursive(__atexit_recursive_mutex);
#endif
return -1;
}
p->_ind = 0;
p->_next = _GLOBAL_ATEXIT;
_GLOBAL_ATEXIT = p;
#ifndef _REENT_SMALL
p->_on_exit_args._fntypes = 0;
p->_on_exit_args._is_cxa = 0;
#else
p->_on_exit_args_ptr = NULL;
#endif
#endif
}
if (type != __et_atexit)
{
#ifdef _REENT_SMALL
args = p->_on_exit_args_ptr;
if (args == NULL)
{
#ifndef _ATEXIT_DYNAMIC_ALLOC
#ifndef __SINGLE_THREAD__
__lock_release_recursive(__atexit_recursive_mutex);
#endif
return -1;
#else
if (malloc)
args = malloc (sizeof * p->_on_exit_args_ptr);
if (args == NULL)
{
#ifndef __SINGLE_THREAD__
__lock_release(__atexit_recursive_mutex);
#endif
return -1;
}
args->_fntypes = 0;
args->_is_cxa = 0;
p->_on_exit_args_ptr = args;
#endif
}
#else
args = &p->_on_exit_args;
#endif
args->_fnargs[p->_ind] = arg;
args->_fntypes |= (1 << p->_ind);
args->_dso_handle[p->_ind] = d;
if (type == __et_cxa)
args->_is_cxa |= (1 << p->_ind);
}
p->_fns[p->_ind++] = fn;
#ifndef __SINGLE_THREAD__
__lock_release_recursive(__atexit_recursive_mutex);
#endif
return 0;
}