X-Git-Url: https://git.saurik.com/apple/libc.git/blobdiff_plain/9385eb3d10ebe5eb398c52040ec3dbfba9b0cdcf..a28bf75d63c6a64e4c3b417c6052e45f42c6cedd:/stdlib/FreeBSD/atexit.c diff --git a/stdlib/FreeBSD/atexit.c b/stdlib/FreeBSD/atexit.c index 51b195b..6acc776 100644 --- a/stdlib/FreeBSD/atexit.c +++ b/stdlib/FreeBSD/atexit.c @@ -13,10 +13,6 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. @@ -38,31 +34,63 @@ static char sccsid[] = "@(#)atexit.c 8.2 (Berkeley) 7/3/94"; #endif /* LIBC_SCCS and not lint */ #include -__FBSDID("$FreeBSD: src/lib/libc/stdlib/atexit.c,v 1.6 2002/03/22 21:53:09 obrien Exp $"); +__FBSDID("$FreeBSD: src/lib/libc/stdlib/atexit.c,v 1.8 2007/01/09 00:28:09 imp Exp $"); #include "namespace.h" #include #include #include #include +#if defined(__DYNAMIC__) || defined (__BLOCKS__) +#include +#endif /* defined(__DYNAMIC__) */ #include "atexit.h" #include "un-namespace.h" +#ifdef __BLOCKS__ +#include +#endif /* __BLOCKS__ */ #include "libc_private.h" +#define ATEXIT_FN_EMPTY 0 +#define ATEXIT_FN_STD 1 +#define ATEXIT_FN_CXA 2 +#ifdef __BLOCKS__ +#define ATEXIT_FN_BLK 3 +#endif /* __BLOCKS__ */ + static pthread_mutex_t atexit_mutex = PTHREAD_MUTEX_INITIALIZER; #define _MUTEX_LOCK(x) if (__isthreaded) _pthread_mutex_lock(x) #define _MUTEX_UNLOCK(x) if (__isthreaded) _pthread_mutex_unlock(x) -struct atexit *__atexit; /* points to head of LIFO stack */ +struct atexit { + struct atexit *next; /* next in list */ + int ind; /* next index in this table */ + struct atexit_fn { + int fn_type; /* ATEXIT_? from above */ + union { + void (*std_func)(void); + void (*cxa_func)(void *); +#ifdef __BLOCKS__ + void (^block)(void); +#endif /* __BLOCKS__ */ + } fn_ptr; /* function pointer */ + void *fn_arg; /* argument for CXA callback */ + void *fn_dso; /* shared module handle */ + } fns[ATEXIT_SIZE]; /* the table itself */ +}; + +static struct atexit *__atexit; /* points to head of LIFO stack */ +static int new_registration; /* - * Register a function to be performed at exit. + * Register the function described by 'fptr' to be called at application + * exit or owning shared object unload time. This is a helper function + * for atexit and __cxa_atexit. */ -int -atexit(fn) - void (*fn)(); +static int +atexit_register(struct atexit_fn *fptr) { static struct atexit __atexit0; /* one guaranteed table */ struct atexit *p; @@ -89,7 +117,124 @@ atexit(fn) p->next = __atexit; __atexit = p; } - p->fns[p->ind++] = fn; + p->fns[p->ind++] = *fptr; + new_registration = 1; + _MUTEX_UNLOCK(&atexit_mutex); + return 0; +} + +/* + * Register a function to be performed at exit. + */ +int +atexit(void (*func)(void)) +{ + struct atexit_fn fn; + struct dl_info info; + int error; + + fn.fn_type = ATEXIT_FN_STD; + fn.fn_ptr.std_func = func; + fn.fn_arg = NULL; +#if defined(__DYNAMIC__) + if ( dladdr(func, &info) ) + fn.fn_dso = info.dli_fbase; + else + fn.fn_dso = NULL; +#else /* ! defined(__DYNAMIC__) */ + fn.fn_dso = NULL; +#endif /* defined(__DYNAMIC__) */ + + error = atexit_register(&fn); + return (error); +} + +#ifdef __BLOCKS__ +int +atexit_b(void (^block)(void)) +{ + struct atexit_fn fn; + struct dl_info info; + int error; + + fn.fn_type = ATEXIT_FN_BLK; + fn.fn_ptr.block = Block_copy(block); + fn.fn_arg = NULL; +#if defined(__DYNAMIC__) + if ( dladdr(block, &info) ) + fn.fn_dso = info.dli_fbase; + else + fn.fn_dso = NULL; +#else /* ! defined(__DYNAMIC__) */ + fn.fn_dso = NULL; +#endif /* defined(__DYNAMIC__) */ + + error = atexit_register(&fn); + return (error); +} +#endif /* __BLOCKS__ */ + +/* + * Register a function to be performed at exit or when an shared object + * with given dso handle is unloaded dynamically. + */ +int +__cxa_atexit(void (*func)(void *), void *arg, void *dso) +{ + struct atexit_fn fn; + int error; + + fn.fn_type = ATEXIT_FN_CXA; + fn.fn_ptr.cxa_func = func;; + fn.fn_arg = arg; + fn.fn_dso = dso; + + error = atexit_register(&fn); + return (error); +} + +/* + * Call all handlers registered with __cxa_atexit for the shared + * object owning 'dso'. Note: if 'dso' is NULL, then all remaining + * handlers are called. + */ +void +__cxa_finalize(const void *dso) +{ + struct atexit *p; + struct atexit_fn fn; + int n; + + _MUTEX_LOCK(&atexit_mutex); +restart: + for (p = __atexit; p; p = p->next) { + for (n = p->ind; --n >= 0;) { + if (p->fns[n].fn_type == ATEXIT_FN_EMPTY) + continue; /* already been called */ + if (dso != NULL && dso != p->fns[n].fn_dso) + continue; /* wrong DSO */ + fn = p->fns[n]; + /* + Mark entry to indicate that this particular handler + has already been called. + */ + p->fns[n].fn_type = ATEXIT_FN_EMPTY; + new_registration = 0; + _MUTEX_UNLOCK(&atexit_mutex); + + /* Call the function of correct type. */ + if (fn.fn_type == ATEXIT_FN_CXA) + fn.fn_ptr.cxa_func(fn.fn_arg); + else if (fn.fn_type == ATEXIT_FN_STD) + fn.fn_ptr.std_func(); +#ifdef __BLOCKS__ + else if (fn.fn_type == ATEXIT_FN_BLK) + fn.fn_ptr.block(); +#endif /* __BLOCKS__ */ + _MUTEX_LOCK(&atexit_mutex); + if (new_registration) + goto restart; + } + } _MUTEX_UNLOCK(&atexit_mutex); - return (0); }