From d28e3a861f97b138a542a335b3f7603bf1794d70 Mon Sep 17 00:00:00 2001 From: "Peter S. Mazinger" Date: Mon, 13 Feb 2006 07:47:26 +0000 Subject: More renames for IMA --- libc/stdlib/atexit.c | 356 --------------------------------------------------- 1 file changed, 356 deletions(-) delete mode 100644 libc/stdlib/atexit.c (limited to 'libc/stdlib/atexit.c') diff --git a/libc/stdlib/atexit.c b/libc/stdlib/atexit.c deleted file mode 100644 index 959d08edb..000000000 --- a/libc/stdlib/atexit.c +++ /dev/null @@ -1,356 +0,0 @@ -/* Copyright (C) 1995,1996 Robert de Bath - * This file is part of the Linux-8086 C library and is distributed - * under the GNU Library General Public License. - */ - -/* - * Dec 2000 Manuel Novoa III - * - * Made atexit handling conform to standards... i.e. no args. - * Removed on_exit since it did not match gnu libc definition. - * Combined atexit and __do_exit into one object file. - * - * Feb 2001 Manuel Novoa III - * - * Reworked file after addition of __uClibc_main. - * Changed name of __do_exit to atexit_handler. - * Changed name of __cleanup to __uClibc_cleanup. - * Moved declaration of __uClibc_cleanup to __uClibc_main - * where it is initialized with (possibly weak alias) - * _stdio_term. - * - * Jul 2001 Steve Thayer - * - * Added an on_exit implementation (that now matches gnu libc definition.) - * Pulled atexit_handler out of the atexit object since it is now required by - * on_exit as well. Renamed it to __exit_handler. - * Fixed a problem where exit functions stop getting called if one of - * them calls exit(). - * As a side effect of these changes, abort() no longer calls the exit - * functions (it now matches the gnu libc definition). - * - * August 2002 Erik Andersen - * Added locking so atexit and friends can be thread safe - * - * August 2005 Stephen Warren - * Added __cxa_atexit and __cxa_finalize support - * - */ - -#include -#include -#include -#include -#include - -libc_hidden_proto(exit) -libc_hidden_proto(_exit) - -#ifdef __UCLIBC_HAS_THREADS__ -# include -extern pthread_mutex_t mylock; -libc_hidden_proto(mylock) -#endif -#define LOCK __pthread_mutex_lock(&mylock) -#define UNLOCK __pthread_mutex_unlock(&mylock) - - -typedef void (*aefuncp) (void); /* atexit function pointer */ -typedef void (*oefuncp) (int, void *); /* on_exit function pointer */ -typedef void (*cxaefuncp) (void *); /* __cxa_atexit function pointer */ -typedef enum { - ef_free, - ef_in_use, - ef_on_exit, - ef_cxa_atexit -} ef_type; /* exit function types */ - -/* this is in the L_exit object */ -extern void (*__exit_cleanup) (int) attribute_hidden; - -/* these are in the L___do_exit object */ -extern int __exit_slots attribute_hidden; -extern int __exit_count attribute_hidden; -extern void __exit_handler(int) attribute_hidden; -struct exit_function { - /* - * 'type' should be of type of the 'enum ef_type' above but since we - * need this element in an atomic operation we have to use 'long int'. - */ - long int type; /* enum ef_type */ - union { - struct { - oefuncp func; - void *arg; - } on_exit; - struct { - cxaefuncp func; - void *arg; - void* dso_handle; - } cxa_atexit; - } funcs; -}; -#ifdef __UCLIBC_DYNAMIC_ATEXIT__ -extern struct exit_function *__exit_function_table attribute_hidden; -#else -extern struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT] attribute_hidden; -#endif -extern struct exit_function *__new_exitfn (void) attribute_hidden; - -/* this is in the L___cxa_atexit object */ -extern int __cxa_atexit (cxaefuncp, void *arg, void *dso_handle); - - -/* remove old_atexit after 0.9.29 */ -#if defined(L_atexit) || defined(L_old_atexit) -extern void *__dso_handle __attribute__ ((__weak__)); - -/* - * register a function to be called at normal program termination - * (the registered function takes no arguments) - */ -#ifdef L_atexit -int attribute_hidden atexit(aefuncp func) -#else -int old_atexit(aefuncp func) -#endif -{ - /* - * glibc casts aefuncp to cxaefuncp. - * This seems dodgy, but I guess callling a function with more - * parameters than it needs will work everywhere? - */ - return __cxa_atexit((cxaefuncp)func, NULL, - &__dso_handle == NULL ? NULL : __dso_handle); -} -#ifndef L_atexit -weak_alias(old_atexit,atexit) -#endif -#endif - -#ifdef L_on_exit -/* - * register a function to be called at normal program termination - * the registered function takes two arguments: - * status - the exit status that was passed to the exit() function - * arg - generic argument - */ -int on_exit(oefuncp func, void *arg) -{ - struct exit_function *efp; - - if (func == NULL) { - return 0; - } - - efp = __new_exitfn(); - if (efp == NULL) { - return -1; - } - - efp->funcs.on_exit.func = func; - efp->funcs.on_exit.arg = arg; - /* assign last for thread safety, since we're now unlocked */ - efp->type = ef_on_exit; - - return 0; -} -#endif - -#ifdef L___cxa_atexit -libc_hidden_proto(__cxa_atexit) -int __cxa_atexit (cxaefuncp func, void *arg, void *dso_handle) -{ - struct exit_function *efp; - - if (func == NULL) { - return 0; - } - - efp = __new_exitfn(); - if (efp == NULL) { - return -1; - } - - efp->funcs.cxa_atexit.func = func; - efp->funcs.cxa_atexit.arg = arg; - efp->funcs.cxa_atexit.dso_handle = dso_handle; - /* assign last for thread safety, since we're now unlocked */ - efp->type = ef_cxa_atexit; - - return 0; -} -libc_hidden_def(__cxa_atexit) -#endif - -#ifdef L___cxa_finalize -/* - * If D is non-NULL, call all functions registered with `__cxa_atexit' - * with the same dso handle. Otherwise, if D is NULL, call all of the - * registered handlers. - */ -void __cxa_finalize (void *dso_handle); -void __cxa_finalize (void *dso_handle) -{ - struct exit_function *efp; - int exit_count_snapshot = __exit_count; - - /* In reverse order */ - while (exit_count_snapshot) { - efp = &__exit_function_table[--exit_count_snapshot]; - - /* - * We check dso_handle match before we verify the type of the union entry. - * However, the atomic_exchange will validate that we were really "allowed" - * to read dso_handle... - */ - if ((dso_handle == NULL || dso_handle == efp->funcs.cxa_atexit.dso_handle) - /* We don't want to run this cleanup more than once. */ - && !atomic_compare_and_exchange_bool_acq(&efp->type, ef_free, ef_cxa_atexit) - ) { - /* glibc passes status (0) too, but that's not in the prototype */ - (*efp->funcs.cxa_atexit.func)(efp->funcs.cxa_atexit.arg); - } - } - -#if 0 /* haven't looked into this yet... */ - /* - * Remove the registered fork handlers. We do not have to - * unregister anything if the program is going to terminate anyway. - */ -#ifdef UNREGISTER_ATFORK - if (d != NULL) { - UNREGISTER_ATFORK (d); - } -#endif -#endif -} -#endif - -#ifdef L___exit_handler -int __exit_count = 0; /* Number of registered exit functions */ -#ifdef __UCLIBC_DYNAMIC_ATEXIT__ -struct exit_function *__exit_function_table = NULL; -int __exit_slots = 0; /* Size of __exit_function_table */ -#else -struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT]; -#endif - -/* - * Find and return a new exit_function pointer, for atexit, - * onexit and __cxa_atexit to initialize - */ -struct exit_function attribute_hidden *__new_exitfn(void) -{ - struct exit_function *efp; - - LOCK; - -#ifdef __UCLIBC_DYNAMIC_ATEXIT__ - /* If we are out of function table slots, make some more */ - if (__exit_slots < __exit_count+1) { - efp=realloc(__exit_function_table, - (__exit_slots+20)*sizeof(struct exit_function)); - if (efp == NULL) { - UNLOCK; - __set_errno(ENOMEM); - return 0; - } - __exit_function_table = efp; - __exit_slots += 20; - } -#else - if (__exit_count >= __UCLIBC_MAX_ATEXIT) { - UNLOCK; - __set_errno(ENOMEM); - return 0; - } -#endif - - __exit_cleanup = __exit_handler; /* enable cleanup */ - efp = &__exit_function_table[__exit_count++]; - efp->type = ef_in_use; - - UNLOCK; - - return efp; -} - -/* - * Handle the work of executing the registered exit functions - * This is called while we are locked, so no additional locking - * is needed... - */ -void __exit_handler(int status) -{ - struct exit_function *efp; - - /* In reverse order */ - while ( __exit_count ) { - efp = &__exit_function_table[--__exit_count]; - switch (efp->type) { - case ef_on_exit: - if (efp->funcs.on_exit.func) { - (efp->funcs.on_exit.func) (status, efp->funcs.on_exit.arg); - } - break; - case ef_cxa_atexit: - if (efp->funcs.cxa_atexit.func) { - /* glibc passes status too, but that's not in the prototype */ - (efp->funcs.cxa_atexit.func) (efp->funcs.cxa_atexit.arg); - } - break; - } - } -#ifdef __UCLIBC_DYNAMIC_ATEXIT__ - /* Free up memory used by the __exit_function_table structure */ - if (__exit_function_table) - free(__exit_function_table); -#endif -} -#endif - -#ifdef L_exit -extern void weak_function _stdio_term(void) attribute_hidden; -attribute_hidden void (*__exit_cleanup) (int) = 0; -#ifdef __UCLIBC_HAS_THREADS__ -pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; -libc_hidden_data_def(mylock) -#endif - -#ifdef __UCLIBC_CTOR_DTOR__ -extern void (*__app_fini)(void); -#endif - -extern void (*__rtld_fini)(void); - -/* - * Normal program termination - */ -void exit(int rv) -{ - /* Perform exit-specific cleanup (atexit and on_exit) */ - LOCK; - if (__exit_cleanup) { - __exit_cleanup(rv); - } - UNLOCK; - -#ifdef __UCLIBC_CTOR_DTOR__ - if (__app_fini != NULL) - (__app_fini)(); -#endif - if (__rtld_fini != NULL) - (__rtld_fini)(); - - /* If we are using stdio, try to shut it down. At the very least, - * this will attempt to commit all buffered writes. It may also - * unbuffer all writable files, or close them outright. - * Check the stdio routines for details. */ - if (_stdio_term) - _stdio_term(); - - _exit(rv); -} -libc_hidden_def(exit) -#endif -- cgit v1.2.3