More renames for IMA

1 files changed, 356 insertions, 0 deletions

diff --git a/libc/stdlib/_atexit.c b/libc/stdlib/_atexit.c
new file mode 100644
index 000000000..959d08edb
--- /dev/null
+++ b/libc/stdlib/_atexit.c
@@ -0,0 +1,356 @@
+/* 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