[multiple changes]
2006-03-23 Geoffrey Keating <geoffk@apple.com> PR 26793 * config/t-darwin (crt3.o): Work around bug 26840. * config/darwin-crt3.c: Rewrite. * config/darwin.h (STARTFILE_SPEC): Don't use -l for crt3.o. Index: gcc/testsuite/ChangeLog 2006-03-24 Geoffrey Keating <geoffk@apple.com> * g++.old-deja/g++.other/init19.C: New. From-SVN: r112361
This commit is contained in:
Geoffrey Keating
Geoffrey Keating
parent
e713adf645
commit
895de5a8a9
7 changed files with 587 additions and 143 deletions
|
|
@ -1,3 +1,10 @@
|
|||
2006-03-24 Geoffrey Keating <geoffk@apple.com>
|
||||
|
||||
PR 26793
|
||||
* config/t-darwin (crt3.o): Work around bug 26840.
|
||||
* config/darwin-crt3.c: Rewrite.
|
||||
* config/darwin.h (STARTFILE_SPEC): Don't use -l for crt3.o.
|
||||
|
||||
2006-03-24 Carlos O'Donell <carlos@codesourcery.com>
|
||||
|
||||
* doc/invoke.texi: Document -femit-class-debug-always
|
||||
|
|
|
|||
|
|
@ -37,172 +37,492 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
|||
#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 one, and having it called from
|
||||
a destructor. This is not quite as good as having a real __cxa_atexit,
|
||||
but it's good enough to imitate the behaviour that you'd get if
|
||||
you didn't have one.
|
||||
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 10.4 Mac OS versions, __cxa_finalize
|
||||
doesn't work right: it doesn't run routines that were registered
|
||||
while other atexit routines are running. This is worked around by
|
||||
installing our own handler so that it runs last, and repeatedly
|
||||
running __cxa_finalize until no new calls to __cxa_atexit are made. */
|
||||
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.
|
||||
|
||||
typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, void* dso);
|
||||
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__
|
||||
void __cxa_finalize (void* dso) __attribute__((weak));
|
||||
#define CHECK_KEYMGR_ERROR(e) \
|
||||
(((_Tinfo_Node *)__keymgr_global[2])->major_version >= 4 ? (e) : 0)
|
||||
#else
|
||||
void __cxa_finalize (void* dso);
|
||||
#define CHECK_KEYMGR_ERROR(e) (e)
|
||||
#endif
|
||||
|
||||
/* new_atexit_routines is set if __cxa_finalize exists in the system C
|
||||
library and our copy of __cxa_atexit has been called. */
|
||||
/* Our globals are stored under this keymgr index. */
|
||||
#define KEYMGR_ATEXIT_LIST 14
|
||||
|
||||
static bool new_atexit_routines;
|
||||
/* The different kinds of callback routines. */
|
||||
typedef void (*atexit_callback)(void);
|
||||
typedef void (*cxa_atexit_callback)(void *);
|
||||
|
||||
/* first_atexit_handler is called after all other atexit routines
|
||||
that were registered before __cxa_finalize is called.
|
||||
It may be called more than once, but is not re-entered. */
|
||||
|
||||
static void
|
||||
first_atexit_handler(void* dso)
|
||||
/* 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
|
||||
{
|
||||
/* Keep running __cxa_finalize until no new atexit routines are
|
||||
registered.
|
||||
Note that this means __cxa_finalize will be called at least twice,
|
||||
even if the first call didn't register any new routines. */
|
||||
while (new_atexit_routines) {
|
||||
new_atexit_routines = false;
|
||||
__cxa_finalize (dso);
|
||||
};
|
||||
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;
|
||||
}
|
||||
|
||||
/* This is our wrapper around __cxa_atexit that's called if __cxa_finalize
|
||||
exists in the system library. All it does is, on its first call,
|
||||
install first_atexit_handler; and on every call, set new_atexit_routines
|
||||
and pass control to the system __cxa_atexit.
|
||||
This proves to be somewhat more complicated than you might expect,
|
||||
because it may be called in a multithreaded environment. Fortunately
|
||||
it turns out to be possible to do what's needed without resorting
|
||||
to locking. */
|
||||
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
|
||||
cxa_atexit_wrapper (void (*func) (void*), void* arg, void* dso)
|
||||
check_cxa_atexit (cxa_atexit_p cxa_atexit, cxa_finalize_p cxa_finalize)
|
||||
{
|
||||
static volatile cxa_atexit_p real_cxa_atexit;
|
||||
cxa_atexit_p auto_cxa_atexit = real_cxa_atexit;
|
||||
if (! auto_cxa_atexit)
|
||||
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)
|
||||
{
|
||||
void* handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
|
||||
if (! handle)
|
||||
return -1;
|
||||
|
||||
auto_cxa_atexit = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
|
||||
if (! auto_cxa_atexit)
|
||||
return -1;
|
||||
/* 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;
|
||||
}
|
||||
/* At this point, auto_cxa_atexit contains the address of
|
||||
the system __cxa_atexit. */
|
||||
if (! real_cxa_atexit)
|
||||
{
|
||||
/* Install our handler above before any other handlers
|
||||
for this image, so it will be called last. */
|
||||
int result = (*auto_cxa_atexit)(first_atexit_handler, dso, dso);
|
||||
if (result != 0)
|
||||
return result;
|
||||
/* Now set the global real_cxa_atexit to prevent further
|
||||
installations of first_atexit_handler. Do this after
|
||||
the installation so that if another thread sees it is set,
|
||||
it can be sure that first_atexit_handler really has been
|
||||
installed. */
|
||||
real_cxa_atexit = auto_cxa_atexit;
|
||||
}
|
||||
/* At this point, we know that first_atexit_handler has been
|
||||
installed at least once, and real_cxa_atexit is not NULL. */
|
||||
/* It's not necessary to mark new_atexit_routines as volatile, so long
|
||||
as this write eventually happens before this shared object is
|
||||
unloaded. */
|
||||
new_atexit_routines = true;
|
||||
/* Call the original __cxa_atexit for this function. */
|
||||
return (*auto_cxa_atexit)(func, arg, dso);
|
||||
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 structure holds a routine to call. */
|
||||
struct atexit_routine
|
||||
/* This routine is called from the system atexit(); it runs everything
|
||||
registered on the KEYMGR_ATEXIT_LIST. */
|
||||
|
||||
static void
|
||||
our_atexit (void)
|
||||
{
|
||||
struct atexit_routine * next;
|
||||
void (*func)(void *);
|
||||
void * arg;
|
||||
};
|
||||
struct keymgr_atexit_list *g;
|
||||
char prev_running;
|
||||
|
||||
static struct atexit_routine * volatile atexit_routines_list;
|
||||
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
|
||||
|
||||
/* If __cxa_atexit doesn't exist at all in the system library, this
|
||||
routine is used; it completely emulates __cxa_atexit.
|
||||
|
||||
This routine has to be thread-safe, but fortunately this just means
|
||||
that it has to do atomic list insertion. */
|
||||
/* 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
|
||||
cxa_atexit_substitute (void (*func) (void*), void* arg,
|
||||
/* The 'dso' value will always be equal to this
|
||||
object's __dso_handle. */
|
||||
void* dso __attribute__((unused)))
|
||||
atexit_common (const struct one_atexit_routine *r, const void *dso)
|
||||
{
|
||||
struct atexit_routine * s = malloc (sizeof (struct atexit_routine));
|
||||
struct atexit_routine * next, * old_next;
|
||||
if (!s)
|
||||
struct keymgr_atexit_list *g = get_globals ();
|
||||
|
||||
if (! g)
|
||||
return -1;
|
||||
s->func = func;
|
||||
s->arg = arg;
|
||||
next = atexit_routines_list;
|
||||
do {
|
||||
s->next = old_next = next;
|
||||
next = __sync_val_compare_and_swap (&atexit_routines_list, old_next, s);
|
||||
} while (next != old_next);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (g->running_routines || g->atexit_status == atexit_status_missing)
|
||||
return add_routine (g, r);
|
||||
|
||||
/* The routines added in cxa_atexit_substitute get run here, in a destructor.
|
||||
This routine doesn't have to be thread-safe. */
|
||||
|
||||
static void cxa_dtor (void) __attribute__((destructor));
|
||||
static void
|
||||
cxa_dtor (void)
|
||||
{
|
||||
while (atexit_routines_list)
|
||||
if (g->atexit_status >= atexit_status_working)
|
||||
{
|
||||
struct atexit_routine * working_list = atexit_routines_list;
|
||||
atexit_routines_list = NULL;
|
||||
while (working_list)
|
||||
int result;
|
||||
if (r->has_arg)
|
||||
{
|
||||
struct atexit_routine * called_routine = working_list;
|
||||
working_list->func (working_list->arg);
|
||||
working_list = working_list->next;
|
||||
free (called_routine);
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
|
||||
struct one_atexit_routine *alloced;
|
||||
int result;
|
||||
|
||||
int __cxa_atexit (void (*func) (void*), void* arg,
|
||||
void* dso) __attribute__((visibility("hidden")));
|
||||
int
|
||||
__cxa_atexit (void (*func) (void*), void* arg, void* dso)
|
||||
{
|
||||
#ifdef __ppc__
|
||||
if (! __cxa_finalize)
|
||||
return cxa_atexit_substitute (func, arg, dso);
|
||||
#endif
|
||||
return cxa_atexit_wrapper (func, arg, dso);
|
||||
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")));
|
||||
|
||||
int
|
||||
atexit (atexit_callback func)
|
||||
{
|
||||
struct one_atexit_routine r;
|
||||
r.callback.ac = func;
|
||||
r.has_arg = 0;
|
||||
return atexit_common (&r, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -341,7 +341,7 @@ Boston, MA 02110-1301, USA. */
|
|||
%{!static:%{object:-lcrt0.o} \
|
||||
%{!object:%{preload:-lcrt0.o} \
|
||||
%{!preload:-lcrt1.o %(darwin_crt2)}}}}}} \
|
||||
%{shared-libgcc:%:version-compare(< 10.5 mmacosx-version-min= -lcrt3.o)}"
|
||||
%{shared-libgcc:%:version-compare(< 10.5 mmacosx-version-min= crt3.o%s)}"
|
||||
|
||||
/* The native Darwin linker doesn't necessarily place files in the order
|
||||
that they're specified on the link line. Thus, it is pointless
|
||||
|
|
|
|||
|
|
@ -14,9 +14,11 @@ gt-darwin.h : s-gtype ; @true
|
|||
|
||||
# How to build crt3.o
|
||||
EXTRA_MULTILIB_PARTS=crt3.o
|
||||
# Pass -fno-tree-dominator-opts to work around bug 26840.
|
||||
$(T)crt3$(objext): $(srcdir)/config/darwin-crt3.c $(GCC_PASSES) \
|
||||
$(TCONFIG_H) stmp-int-hdrs tsystem.h
|
||||
$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(INCLUDES) $(MULTILIB_CFLAGS) \
|
||||
-fno-tree-dominator-opts \
|
||||
-c $(srcdir)/config/darwin-crt3.c -o $(T)crt3$(objext)
|
||||
|
||||
# Use unwind-dw2-fde-darwin
|
||||
|
|
|
|||
|
|
@ -5326,8 +5326,9 @@ is_c_family (void)
|
|||
{
|
||||
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
|
||||
|
||||
return (lang == DW_LANG_C || lang == DW_LANG_C89
|
||||
|| lang == DW_LANG_C_plus_plus);
|
||||
return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
|
||||
|| lang == DW_LANG_C99
|
||||
|| lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
|
||||
}
|
||||
|
||||
/* Return TRUE if the language is C++. */
|
||||
|
|
@ -5335,8 +5336,9 @@ is_c_family (void)
|
|||
static inline bool
|
||||
is_cxx (void)
|
||||
{
|
||||
return (get_AT_unsigned (comp_unit_die, DW_AT_language)
|
||||
== DW_LANG_C_plus_plus);
|
||||
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
|
||||
|
||||
return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
|
||||
}
|
||||
|
||||
/* Return TRUE if the language is Fortran. */
|
||||
|
|
@ -9927,6 +9929,23 @@ add_const_value_attribute (dw_die_ref die, rtx rtl)
|
|||
|
||||
}
|
||||
|
||||
/* Determine whether the evaluation of EXPR references any variables
|
||||
or functions which aren't otherwise used (and therefore may not be
|
||||
output). */
|
||||
static tree
|
||||
reference_to_unused (tree * tp, int * walk_subtrees,
|
||||
void * data ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
|
||||
*walk_subtrees = 0;
|
||||
|
||||
if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
|
||||
&& ! TREE_ASM_WRITTEN (*tp))
|
||||
return *tp;
|
||||
else
|
||||
return NULL_TREE;
|
||||
}
|
||||
|
||||
/* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
|
||||
for use in a later add_const_value_attribute call. */
|
||||
|
||||
|
|
@ -9953,15 +9972,16 @@ rtl_for_decl_init (tree init, tree type)
|
|||
rtl = gen_rtx_CONST_STRING (VOIDmode,
|
||||
ggc_strdup (TREE_STRING_POINTER (init)));
|
||||
}
|
||||
/* Although DWARF could easily handle other kinds of aggregates, we
|
||||
have no way to represent such values as RTL constants, so skip
|
||||
those. */
|
||||
else if (AGGREGATE_TYPE_P (type))
|
||||
;
|
||||
/* If the initializer is something that we know will expand into an
|
||||
immediate RTL constant, expand it now. Expanding anything else
|
||||
tends to produce unresolved symbols; see debug/5770 and c++/6381. */
|
||||
/* Aggregate, vector, and complex types may contain constructors that may
|
||||
result in code being generated when expand_expr is called, so we can't
|
||||
handle them here. Integer and float are useful and safe types to handle
|
||||
here. */
|
||||
else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
|
||||
&& initializer_constant_valid_p (init, type) == null_pointer_node)
|
||||
immediate RTL constant, expand it now. We must be careful not to
|
||||
reference variables which won't be output. */
|
||||
else if (initializer_constant_valid_p (init, type)
|
||||
&& ! walk_tree (&init, reference_to_unused, NULL, NULL))
|
||||
{
|
||||
rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
|
||||
|
||||
|
|
@ -10325,6 +10345,9 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl,
|
|||
add_AT_location_description (die, attr, descr);
|
||||
return;
|
||||
}
|
||||
/* None of that worked, so it must not really have a location;
|
||||
try adding a constant value attribute from the DECL_INITIAL. */
|
||||
tree_add_const_value_attribute (die, decl);
|
||||
}
|
||||
|
||||
/* If we don't have a copy of this variable in memory for some reason (such
|
||||
|
|
@ -12204,6 +12227,10 @@ gen_compile_unit_die (const char *filename)
|
|||
language = DW_LANG_Pascal83;
|
||||
else if (strcmp (language_string, "GNU Java") == 0)
|
||||
language = DW_LANG_Java;
|
||||
else if (strcmp (language_string, "GNU Objective-C") == 0)
|
||||
language = DW_LANG_ObjC;
|
||||
else if (strcmp (language_string, "GNU Objective-C++") == 0)
|
||||
language = DW_LANG_ObjC_plus_plus;
|
||||
else
|
||||
language = DW_LANG_C89;
|
||||
|
||||
|
|
@ -13314,8 +13341,7 @@ dwarf2out_decl (tree decl)
|
|||
{
|
||||
/* OK, we need to generate one for `bool' so GDB knows what type
|
||||
comparisons have. */
|
||||
if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
|
||||
== DW_LANG_C_plus_plus)
|
||||
if (is_cxx ()
|
||||
&& TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
|
||||
&& ! DECL_IGNORED_P (decl))
|
||||
modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,7 @@
|
|||
2006-03-24 Geoffrey Keating <geoffk@apple.com>
|
||||
|
||||
* g++.old-deja/g++.other/init19.C: New.
|
||||
|
||||
2006-03-24 David Edelsohn <edelsohn@gnu.org>
|
||||
|
||||
* g++.dg/eh/spbp.C: Skip on AIX.
|
||||
|
|
|
|||
85
gcc/testsuite/g++.old-deja/g++.other/init19.C
Normal file
85
gcc/testsuite/g++.old-deja/g++.other/init19.C
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
// { dg-do run }
|
||||
#include <stdlib.h>
|
||||
|
||||
#define assert(x) do { if (! (x)) abort(); } while (0)
|
||||
|
||||
int count = 0;
|
||||
|
||||
class A
|
||||
{
|
||||
public:
|
||||
explicit A(int i);
|
||||
~A();
|
||||
|
||||
int i;
|
||||
|
||||
A(const A&);
|
||||
A& operator=(const A&);
|
||||
};
|
||||
|
||||
A::A(int i_)
|
||||
: i(i_)
|
||||
{
|
||||
}
|
||||
|
||||
A::~A()
|
||||
{
|
||||
assert(++count == i);
|
||||
i = -1;
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
void one()
|
||||
{
|
||||
static bool second_time;
|
||||
if (second_time)
|
||||
assert(++count == 9);
|
||||
else
|
||||
{
|
||||
assert(++count == 1);
|
||||
second_time = true;
|
||||
}
|
||||
static A a(10);
|
||||
assert(a.i == 10);
|
||||
}
|
||||
|
||||
void two()
|
||||
{
|
||||
assert(++count == 7);
|
||||
static A a(8);
|
||||
assert(a.i == 8);
|
||||
}
|
||||
|
||||
void three()
|
||||
{
|
||||
assert(++count == 2);
|
||||
static A a(6);
|
||||
assert(a.i == 6);
|
||||
}
|
||||
|
||||
void five()
|
||||
{
|
||||
assert(++count == 4);
|
||||
static A a(5);
|
||||
assert(a.i == 5);
|
||||
}
|
||||
|
||||
void four()
|
||||
{
|
||||
assert(++count == 3);
|
||||
atexit(five);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
A zero(11);
|
||||
|
||||
int main()
|
||||
{
|
||||
one();
|
||||
atexit(one);
|
||||
atexit(two);
|
||||
three();
|
||||
atexit(four);
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue