URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [config/] [darwin-crt3.c] - Rev 856
Go to most recent revision | Compare with Previous | Blame | View Log
/* __cxa_atexit backwards-compatibility support for Darwin. Copyright (C) 2006 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. In addition to the permissions in the GNU General Public License, the Free Software Foundation gives you unlimited permission to link the compiled version of this file into combinations with other programs, and to distribute those combinations without any restriction coming from the use of this file. (The General Public License restrictions do apply in other respects; for example, they cover modification of the file, and distribution when not linked into a combine executable.) GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* Don't do anything if we are compiling for a kext multilib. */ #ifdef __PIC__ /* It is incorrect to include config.h here, because this file is being compiled for the target, and hence definitions concerning only the host do not apply. */ #include "tconfig.h" #include "tsystem.h" #include <dlfcn.h> #include <stdbool.h> #include <stdlib.h> #include <string.h> /* This file works around two different problems. The first problem is that there is no __cxa_atexit on Mac OS versions before 10.4. It fixes this by providing a complete atexit and __cxa_atexit emulation called from the regular atexit. The second problem is that on all shipping versions of Mac OS, __cxa_finalize and exit() don't work right: they don't run routines that were registered while other atexit routines are running. This is worked around by wrapping each atexit/__cxa_atexit routine with our own routine which ensures that any __cxa_atexit calls while it is running are honoured. There are still problems which this does not solve. Before 10.4, shared objects linked with previous compilers won't have their atexit calls properly interleaved with code compiled with newer compilers. Also, atexit routines registered from shared objects linked with previous compilers won't get the bug fix. */ typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, const void* dso); typedef void (*cxa_finalize_p)(const void *dso); typedef int (*atexit_p)(void (*func)(void)); /* These are from "keymgr.h". */ extern void *_keymgr_get_and_lock_processwide_ptr (unsigned key); extern int _keymgr_get_and_lock_processwide_ptr_2 (unsigned, void **); extern int _keymgr_set_and_unlock_processwide_ptr (unsigned key, void *ptr); extern void *__keymgr_global[]; typedef struct _Sinfo_Node { unsigned int size ; /*size of this node*/ unsigned short major_version ; /*API major version.*/ unsigned short minor_version ; /*API minor version.*/ } _Tinfo_Node ; #ifdef __ppc__ #define CHECK_KEYMGR_ERROR(e) \ (((_Tinfo_Node *)__keymgr_global[2])->major_version >= 4 ? (e) : 0) #else #define CHECK_KEYMGR_ERROR(e) (e) #endif /* Our globals are stored under this keymgr index. */ #define KEYMGR_ATEXIT_LIST 14 /* The different kinds of callback routines. */ typedef void (*atexit_callback)(void); typedef void (*cxa_atexit_callback)(void *); /* This structure holds a routine to call. There may be extra fields at the end of the structure that this code doesn't know about. */ struct one_atexit_routine { union { atexit_callback ac; cxa_atexit_callback cac; } callback; /* has_arg is 0/2/4 if 'ac' is live, 1/3/5 if 'cac' is live. Higher numbers indicate a later version of the structure that this code doesn't understand and will ignore. */ int has_arg; void * arg; }; struct atexit_routine_list { struct atexit_routine_list * next; struct one_atexit_routine r; }; /* The various possibilities for status of atexit(). */ enum atexit_status { atexit_status_unknown = 0, atexit_status_missing = 1, atexit_status_broken = 2, atexit_status_working = 16 }; struct keymgr_atexit_list { /* Version of this list. This code knows only about version 0. If the version is higher than 0, this code may add new atexit routines but should not attempt to run the list. */ short version; /* 1 if an atexit routine is currently being run by this code, 0 otherwise. */ char running_routines; /* Holds a value from 'enum atexit_status'. */ unsigned char atexit_status; /* The list of atexit and cxa_atexit routines registered. If atexit_status_missing it contains all routines registered while linked with this code. If atexit_status_broken it contains all routines registered during cxa_finalize while linked with this code. */ struct atexit_routine_list *l; /* &__cxa_atexit; set if atexit_status >= atexit_status_broken. */ cxa_atexit_p cxa_atexit_f; /* &__cxa_finalize; set if atexit_status >= atexit_status_broken. */ cxa_finalize_p cxa_finalize_f; /* &atexit; set if atexit_status >= atexit_status_working or atexit_status == atexit_status_missing. */ atexit_p atexit_f; }; /* Return 0 if __cxa_atexit has the bug it has in Mac OS 10.4: it fails to call routines registered while an atexit routine is running. Return 1 if it works properly, and -1 if an error occurred. */ struct atexit_data { int result; cxa_atexit_p cxa_atexit; }; static void cxa_atexit_check_2 (void *arg) { ((struct atexit_data *)arg)->result = 1; } static void cxa_atexit_check_1 (void *arg) { struct atexit_data * aed = arg; if (aed->cxa_atexit (cxa_atexit_check_2, arg, arg) != 0) aed->result = -1; } static int check_cxa_atexit (cxa_atexit_p cxa_atexit, cxa_finalize_p cxa_finalize) { struct atexit_data aed = { 0, cxa_atexit }; /* We re-use &aed as the 'dso' parameter, since it's a unique address. */ if (cxa_atexit (cxa_atexit_check_1, &aed, &aed) != 0) return -1; cxa_finalize (&aed); if (aed.result == 0) { /* Call __cxa_finalize again to make sure that cxa_atexit_check_2 is removed from the list before AED goes out of scope. */ cxa_finalize (&aed); aed.result = 0; } return aed.result; } #ifdef __ppc__ /* This comes from Csu. It works only before 10.4. The prototype has been altered a bit to avoid casting. */ extern int _dyld_func_lookup(const char *dyld_func_name, void *address) __attribute__((visibility("hidden"))); static void our_atexit (void); /* We're running on 10.3.9. Find the address of the system atexit() function. So easy to say, so hard to do. */ static atexit_p find_atexit_10_3 (void) { unsigned int (*dyld_image_count_fn)(void); const char *(*dyld_get_image_name_fn)(unsigned int image_index); const void *(*dyld_get_image_header_fn)(unsigned int image_index); const void *(*NSLookupSymbolInImage_fn)(const void *image, const char *symbolName, unsigned int options); void *(*NSAddressOfSymbol_fn)(const void *symbol); unsigned i, count; /* Find some dyld functions. */ _dyld_func_lookup("__dyld_image_count", &dyld_image_count_fn); _dyld_func_lookup("__dyld_get_image_name", &dyld_get_image_name_fn); _dyld_func_lookup("__dyld_get_image_header", &dyld_get_image_header_fn); _dyld_func_lookup("__dyld_NSLookupSymbolInImage", &NSLookupSymbolInImage_fn); _dyld_func_lookup("__dyld_NSAddressOfSymbol", &NSAddressOfSymbol_fn); /* If any of these don't exist, that's an error. */ if (! dyld_image_count_fn || ! dyld_get_image_name_fn || ! dyld_get_image_header_fn || ! NSLookupSymbolInImage_fn || ! NSAddressOfSymbol_fn) return NULL; count = dyld_image_count_fn (); for (i = 0; i < count; i++) { const char * path = dyld_get_image_name_fn (i); const void * image; const void * symbol; if (strcmp (path, "/usr/lib/libSystem.B.dylib") != 0) continue; image = dyld_get_image_header_fn (i); if (! image) return NULL; /* '4' is NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR. */ symbol = NSLookupSymbolInImage_fn (image, "_atexit", 4); if (! symbol) return NULL; return NSAddressOfSymbol_fn (symbol); } return NULL; } #endif /* Create (if necessary), find, lock, fill in, and return our globals. Return NULL on error, in which case the globals will not be locked. The caller should call keymgr_set_and_unlock. */ static struct keymgr_atexit_list * get_globals (void) { struct keymgr_atexit_list * r; #ifdef __ppc__ /* 10.3.9 doesn't have _keymgr_get_and_lock_processwide_ptr_2 so the PPC side can't use it. On 10.4 this just means the error gets reported a little later when _keymgr_set_and_unlock_processwide_ptr finds that the key was never locked. */ r = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); #else void * rr; if (_keymgr_get_and_lock_processwide_ptr_2 (KEYMGR_ATEXIT_LIST, &rr)) return NULL; r = rr; #endif if (r == NULL) { r = calloc (sizeof (struct keymgr_atexit_list), 1); if (! r) return NULL; } if (r->atexit_status == atexit_status_unknown) { void *handle; handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD); if (!handle) { #ifdef __ppc__ r->atexit_status = atexit_status_missing; r->atexit_f = find_atexit_10_3 (); if (! r->atexit_f) goto error; if (r->atexit_f (our_atexit)) goto error; #else goto error; #endif } else { int chk_result; r->cxa_atexit_f = (cxa_atexit_p)dlsym (handle, "__cxa_atexit"); r->cxa_finalize_f = (cxa_finalize_p)dlsym (handle, "__cxa_finalize"); if (! r->cxa_atexit_f || ! r->cxa_finalize_f) goto error; chk_result = check_cxa_atexit (r->cxa_atexit_f, r->cxa_finalize_f); if (chk_result == -1) goto error; else if (chk_result == 0) r->atexit_status = atexit_status_broken; else { r->atexit_f = (atexit_p)dlsym (handle, "atexit"); if (! r->atexit_f) goto error; r->atexit_status = atexit_status_working; } } } return r; error: _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, r); return NULL; } /* Add TO_ADD to ATEXIT_LIST. ATEXIT_LIST may be NULL but is always the result of calling _keymgr_get_and_lock_processwide_ptr and so KEYMGR_ATEXIT_LIST is known to be locked; this routine is responsible for unlocking it. */ static int add_routine (struct keymgr_atexit_list * g, const struct one_atexit_routine * to_add) { struct atexit_routine_list * s = malloc (sizeof (struct atexit_routine_list)); int result; if (!s) { _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); return -1; } s->r = *to_add; s->next = g->l; g->l = s; result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); return CHECK_KEYMGR_ERROR (result) == 0 ? 0 : -1; } /* This runs the routines in G->L up to STOP. */ static struct keymgr_atexit_list * run_routines (struct keymgr_atexit_list *g, struct atexit_routine_list *stop) { for (;;) { struct atexit_routine_list * cur = g->l; if (! cur || cur == stop) break; g->l = cur->next; _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); switch (cur->r.has_arg) { case 0: case 2: case 4: cur->r.callback.ac (); break; case 1: case 3: case 5: cur->r.callback.cac (cur->r.arg); break; default: /* Don't understand, so don't call it. */ break; } free (cur); g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); if (! g) break; } return g; } /* Call the routine described by ROUTINE_PARAM and then call any routines added to KEYMGR_ATEXIT_LIST while that routine was running, all with in_cxa_finalize set. */ static void cxa_atexit_wrapper (void* routine_param) { struct one_atexit_routine * routine = routine_param; struct keymgr_atexit_list *g; struct atexit_routine_list * base = NULL; char prev_running = 0; g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); if (g) { prev_running = g->running_routines; g->running_routines = 1; base = g->l; _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); } if (routine->has_arg) routine->callback.cac (routine->arg); else routine->callback.ac (); if (g) g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); if (g) g = run_routines (g, base); if (g) { g->running_routines = prev_running; _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); } } #ifdef __ppc__ /* This code is used while running on 10.3.9, when __cxa_atexit doesn't exist in the system library. 10.3.9 only supported regular PowerPC, so this code isn't necessary on x86 or ppc64. */ /* This routine is called from the system atexit(); it runs everything registered on the KEYMGR_ATEXIT_LIST. */ static void our_atexit (void) { struct keymgr_atexit_list *g; char prev_running; g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); if (! g || g->version != 0 || g->atexit_status != atexit_status_missing) return; prev_running = g->running_routines; g->running_routines = 1; g = run_routines (g, NULL); if (! g) return; g->running_routines = prev_running; _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); } #endif /* This is our wrapper around atexit and __cxa_atexit. It will return nonzero if an error occurs, and otherwise: - if in_cxa_finalize is set, or running on 10.3.9, add R to KEYMGR_ATEXIT_LIST; or - call the system __cxa_atexit to add cxa_atexit_wrapper with an argument that indicates how cxa_atexit_wrapper should call R. */ static int atexit_common (const struct one_atexit_routine *r, const void *dso) { struct keymgr_atexit_list *g = get_globals (); if (! g) return -1; if (g->running_routines || g->atexit_status == atexit_status_missing) return add_routine (g, r); if (g->atexit_status >= atexit_status_working) { int result; if (r->has_arg) { cxa_atexit_p cxa_atexit = g->cxa_atexit_f; result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); if (CHECK_KEYMGR_ERROR (result)) return -1; return cxa_atexit (r->callback.cac, r->arg, dso); } else { atexit_p atexit_f = g->atexit_f; result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); if (CHECK_KEYMGR_ERROR (result)) return -1; return atexit_f (r->callback.ac); } } else { cxa_atexit_p cxa_atexit = g->cxa_atexit_f; struct one_atexit_routine *alloced; int result; result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g); if (CHECK_KEYMGR_ERROR (result)) return -1; alloced = malloc (sizeof (struct one_atexit_routine)); if (! alloced) return -1; *alloced = *r; return cxa_atexit (cxa_atexit_wrapper, alloced, dso); } } /* These are the actual replacement routines; they just funnel into atexit_common. */ int __cxa_atexit (cxa_atexit_callback func, void* arg, const void* dso) __attribute__((visibility("hidden"))); int __cxa_atexit (cxa_atexit_callback func, void* arg, const void* dso) { struct one_atexit_routine r; r.callback.cac = func; r.has_arg = 1; r.arg = arg; return atexit_common (&r, dso); } int atexit (atexit_callback func) __attribute__((visibility("hidden"))); /* Use __dso_handle to allow even bundles that call atexit() to be unloaded on 10.4. */ extern void __dso_handle; int atexit (atexit_callback func) { struct one_atexit_routine r; r.callback.ac = func; r.has_arg = 0; return atexit_common (&r, &__dso_handle); } #endif /* __PIC__ */
Go to most recent revision | Compare with Previous | Blame | View Log