More renames for IMA

1 files changed, 0 insertions, 356 deletions

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 <rdebath@cix.compulink.co.uk>
- * 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 <features.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <atomic.h>
-
-libc_hidden_proto(exit)
-libc_hidden_proto(_exit)
-
-#ifdef __UCLIBC_HAS_THREADS__
-# include <pthread.h>
-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