gcc/crtstuff.c

   1 /* Specialized bits of code needed to support construction and
   2    destruction of file-scope objects in C++ code.
   3    Copyright (C) 1991, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   5    Contributed by Ron Guilmette (rfg@monkeys.com).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 In addition to the permissions in the GNU General Public License, the
  15 Free Software Foundation gives you unlimited permission to link the
  16 compiled version of this file into combinations with other programs,
  17 and to distribute those combinations without any restriction coming
  18 from the use of this file.  (The General Public License restrictions
  19 do apply in other respects; for example, they cover modification of
  20 the file, and distribution when not linked into a combine
  21 executable.)
  22
  23 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  24 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  25 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  26 for more details.
  27
  28 You should have received a copy of the GNU General Public License
  29 along with GCC; see the file COPYING.  If not, write to the Free
  30 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  31 02110-1301, USA.  */
  32
  33 /* This file is a bit like libgcc2.c in that it is compiled
  34    multiple times and yields multiple .o files.
  35
  36    This file is useful on target machines where the object file format
  37    supports multiple "user-defined" sections (e.g. COFF, ELF, ROSE).  On
  38    such systems, this file allows us to avoid running collect (or any
  39    other such slow and painful kludge).  Additionally, if the target
  40    system supports a .init section, this file allows us to support the
  41    linking of C++ code with a non-C++ main program.
  42
  43    Note that if INIT_SECTION_ASM_OP is defined in the tm.h file, then
  44    this file *will* make use of the .init section.  If that symbol is
  45    not defined however, then the .init section will not be used.
  46
  47    Currently, only ELF and COFF are supported.  It is likely however that
  48    ROSE could also be supported, if someone was willing to do the work to
  49    make whatever (small?) adaptations are needed.  (Some work may be
  50    needed on the ROSE assembler and linker also.)
  51
  52    This file must be compiled with gcc.  */
  53
  54 /* Target machine header files require this define. */
  55 #define IN_LIBGCC2
  56
  57 /* FIXME: Including auto-host is incorrect, but until we have
  58    identified the set of defines that need to go into auto-target.h,
  59    this will have to do.  */
  60 #include "auto-host.h"
  61 #undef gid_t
  62 #undef pid_t
  63 #undef rlim_t
  64 #undef ssize_t
  65 #undef uid_t
  66 #undef vfork
  67 #include "tconfig.h"
  68 #include "tsystem.h"
  69 #include "coretypes.h"
  70 #include "tm.h"
  71 #include "unwind-dw2-fde.h"
  72
  73 #ifndef FORCE_CODE_SECTION_ALIGN
  74 # define FORCE_CODE_SECTION_ALIGN
  75 #endif
  76
  77 #ifndef CRT_CALL_STATIC_FUNCTION
  78 # define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)     \
  79 static void __attribute__((__used__))                   \
  80 call_ ## FUNC (void)                                    \
  81 {                                                       \
  82   asm (SECTION_OP);                                     \
  83   FUNC ();                                              \
  84   FORCE_CODE_SECTION_ALIGN                              \
  85   asm (TEXT_SECTION_ASM_OP);                            \
  86 }
  87 #endif
  88
  89 #if defined(OBJECT_FORMAT_ELF) \
  90     && !defined(OBJECT_FORMAT_FLAT) \
  91     && defined(HAVE_LD_EH_FRAME_HDR) \
  92     && !defined(inhibit_libc) && !defined(CRTSTUFFT_O) \
  93     && defined(__GLIBC__) && __GLIBC__ >= 2
  94 #include <link.h>
  95 /* uClibc pretends to be glibc 2.2 and DT_CONFIG is defined in its link.h.
  96    But it doesn't use PT_GNU_EH_FRAME ELF segment currently.  */
  97 # if !defined(__UCLIBC__) \
  98      && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \
  99      || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)))
 100 #  define USE_PT_GNU_EH_FRAME
 101 # endif
 102 #endif
 103 #if defined(EH_FRAME_SECTION_NAME) && !defined(USE_PT_GNU_EH_FRAME)
 104 # define USE_EH_FRAME_REGISTRY
 105 #endif
 106 #if defined(EH_FRAME_SECTION_NAME) && EH_TABLES_CAN_BE_READ_ONLY
 107 # define EH_FRAME_SECTION_CONST const
 108 #else
 109 # define EH_FRAME_SECTION_CONST
 110 #endif
 111
 112 #if !defined(DTOR_LIST_END) && defined(OBJECT_FORMAT_ELF) \
 113     && defined(HAVE_GAS_HIDDEN) && !defined(FINI_ARRAY_SECTION_ASM_OP)
 114 # define HIDDEN_DTOR_LIST_END
 115 #endif
 116
 117 /* We do not want to add the weak attribute to the declarations of these
 118    routines in unwind-dw2-fde.h because that will cause the definition of
 119    these symbols to be weak as well.
 120
 121    This exposes a core issue, how to handle creating weak references vs
 122    how to create weak definitions.  Either we have to have the definition
 123    of TARGET_WEAK_ATTRIBUTE be conditional in the shared header files or
 124    have a second declaration if we want a function's references to be weak,
 125    but not its definition.
 126
 127    Making TARGET_WEAK_ATTRIBUTE conditional seems like a good solution until
 128    one thinks about scaling to larger problems -- i.e., the condition under
 129    which TARGET_WEAK_ATTRIBUTE is active will eventually get far too
 130    complicated.
 131
 132    So, we take an approach similar to #pragma weak -- we have a second
 133    declaration for functions that we want to have weak references.
 134
 135    Neither way is particularly good.  */
 136
 137 /* References to __register_frame_info and __deregister_frame_info should
 138    be weak in this file if at all possible.  */
 139 extern void __register_frame_info (const void *, struct object *)
 140                                   TARGET_ATTRIBUTE_WEAK;
 141 extern void __register_frame_info_bases (const void *, struct object *,
 142                                          void *, void *)
 143                                   TARGET_ATTRIBUTE_WEAK;
 144 extern void *__deregister_frame_info (const void *)
 145                                      TARGET_ATTRIBUTE_WEAK;
 146 extern void *__deregister_frame_info_bases (const void *)
 147                                      TARGET_ATTRIBUTE_WEAK;
 148 extern void __do_global_ctors_1 (void);
 149
 150 /* Likewise for _Jv_RegisterClasses.  */
 151 extern void _Jv_RegisterClasses (void *) TARGET_ATTRIBUTE_WEAK;
 152
 153 #ifdef OBJECT_FORMAT_ELF
 154
 155 /*  Declare a pointer to void function type.  */
 156 typedef void (*func_ptr) (void);
 157 #define STATIC static
 158
 159 #else  /* OBJECT_FORMAT_ELF */
 160
 161 #include "gbl-ctors.h"
 162
 163 #define STATIC
 164
 165 #endif /* OBJECT_FORMAT_ELF */
 166
 167 #ifdef CRT_BEGIN
 168
 169 /* NOTE:  In order to be able to support SVR4 shared libraries, we arrange
 170    to have one set of symbols { __CTOR_LIST__, __DTOR_LIST__, __CTOR_END__,
 171    __DTOR_END__ } per root executable and also one set of these symbols
 172    per shared library.  So in any given whole process image, we may have
 173    multiple definitions of each of these symbols.  In order to prevent
 174    these definitions from conflicting with one another, and in order to
 175    ensure that the proper lists are used for the initialization/finalization
 176    of each individual shared library (respectively), we give these symbols
 177    only internal (i.e. `static') linkage, and we also make it a point to
 178    refer to only the __CTOR_END__ symbol in crtend.o and the __DTOR_LIST__
 179    symbol in crtbegin.o, where they are defined.  */
 180
 181 /* The -1 is a flag to __do_global_[cd]tors indicating that this table
 182    does not start with a count of elements.  */
 183 #ifdef CTOR_LIST_BEGIN
 184 CTOR_LIST_BEGIN;
 185 #elif defined(CTORS_SECTION_ASM_OP)
 186 /* Hack: force cc1 to switch to .data section early, so that assembling
 187    __CTOR_LIST__ does not undo our behind-the-back change to .ctors.  */
 188 static func_ptr force_to_data[1] __attribute__ ((__unused__)) = { };
 189 asm (CTORS_SECTION_ASM_OP);
 190 STATIC func_ptr __CTOR_LIST__[1]
 191   __attribute__ ((__unused__, aligned(sizeof(func_ptr))))
 192   = { (func_ptr) (-1) };
 193 #else
 194 STATIC func_ptr __CTOR_LIST__[1]
 195   __attribute__ ((__unused__, section(".ctors"), aligned(sizeof(func_ptr))))
 196   = { (func_ptr) (-1) };
 197 #endif /* __CTOR_LIST__ alternatives */
 198
 199 #ifdef DTOR_LIST_BEGIN
 200 DTOR_LIST_BEGIN;
 201 #elif defined(DTORS_SECTION_ASM_OP)
 202 asm (DTORS_SECTION_ASM_OP);
 203 STATIC func_ptr __DTOR_LIST__[1]
 204   __attribute__ ((aligned(sizeof(func_ptr))))
 205   = { (func_ptr) (-1) };
 206 #else
 207 STATIC func_ptr __DTOR_LIST__[1]
 208   __attribute__((section(".dtors"), aligned(sizeof(func_ptr))))
 209   = { (func_ptr) (-1) };
 210 #endif /* __DTOR_LIST__ alternatives */
 211
 212 #ifdef USE_EH_FRAME_REGISTRY
 213 /* Stick a label at the beginning of the frame unwind info so we can register
 214    and deregister it with the exception handling library code.  */
 215 STATIC EH_FRAME_SECTION_CONST char __EH_FRAME_BEGIN__[]
 216      __attribute__((section(EH_FRAME_SECTION_NAME), aligned(4)))
 217      = { };
 218 #endif /* USE_EH_FRAME_REGISTRY */
 219
 220 #ifdef JCR_SECTION_NAME
 221 /* Stick a label at the beginning of the java class registration info
 222    so we can register them properly.  */
 223 STATIC void *__JCR_LIST__[]
 224   __attribute__ ((unused, section(JCR_SECTION_NAME), aligned(sizeof(void*))))
 225   = { };
 226 #endif /* JCR_SECTION_NAME */
 227
 228 #if defined(INIT_SECTION_ASM_OP) || defined(INIT_ARRAY_SECTION_ASM_OP)
 229
 230 #ifdef OBJECT_FORMAT_ELF
 231
 232 /* Declare the __dso_handle variable.  It should have a unique value
 233    in every shared-object; in a main program its value is zero.  The
 234    object should in any case be protected.  This means the instance
 235    in one DSO or the main program is not used in another object.  The
 236    dynamic linker takes care of this.  */
 237
 238 #ifdef TARGET_LIBGCC_SDATA_SECTION
 239 extern void *__dso_handle __attribute__ ((__section__ (TARGET_LIBGCC_SDATA_SECTION)));
 240 #endif
 241 #ifdef HAVE_GAS_HIDDEN
 242 extern void *__dso_handle __attribute__ ((__visibility__ ("hidden")));
 243 #endif
 244 #ifdef CRTSTUFFS_O
 245 void *__dso_handle = &__dso_handle;
 246 #else
 247 void *__dso_handle = 0;
 248 #endif
 249
 250 /* The __cxa_finalize function may not be available so we use only a
 251    weak declaration.  */
 252 extern void __cxa_finalize (void *) TARGET_ATTRIBUTE_WEAK;
 253
 254 /* Run all the global destructors on exit from the program.  */
 255
 256 /* Some systems place the number of pointers in the first word of the
 257    table.  On SVR4 however, that word is -1.  In all cases, the table is
 258    null-terminated.  On SVR4, we start from the beginning of the list and
 259    invoke each per-compilation-unit destructor routine in order
 260    until we find that null.
 261
 262    Note that this function MUST be static.  There will be one of these
 263    functions in each root executable and one in each shared library, but
 264    although they all have the same code, each one is unique in that it
 265    refers to one particular associated `__DTOR_LIST__' which belongs to the
 266    same particular root executable or shared library file.
 267
 268    On some systems, this routine is run more than once from the .fini,
 269    when exit is called recursively, so we arrange to remember where in
 270    the list we left off processing, and we resume at that point,
 271    should we be re-invoked.  */
 272
 273 static void __attribute__((used))
 274 __do_global_dtors_aux (void)
 275 {
 276   static _Bool completed;
 277
 278   if (__builtin_expect (completed, 0))
 279     return;
 280
 281 #ifdef CRTSTUFFS_O
 282   if (__cxa_finalize)
 283     __cxa_finalize (__dso_handle);
 284 #endif
 285
 286 #ifdef FINI_ARRAY_SECTION_ASM_OP
 287   /* If we are using .fini_array then destructors will be run via that
 288      mechanism.  */
 289 #elif defined(HIDDEN_DTOR_LIST_END)
 290   {
 291     /* Safer version that makes sure only .dtors function pointers are
 292        called even if the static variable is maliciously changed.  */
 293     extern func_ptr __DTOR_END__[] __attribute__((visibility ("hidden")));
 294     static size_t dtor_idx;
 295     const size_t max_idx = __DTOR_END__ - __DTOR_LIST__ - 1;
 296     func_ptr f;
 297
 298     while (dtor_idx < max_idx)
 299       {
 300         f = __DTOR_LIST__[++dtor_idx];
 301         f ();
 302       }
 303   }
 304 #else /* !defined (FINI_ARRAY_SECTION_ASM_OP) */
 305   {
 306     static func_ptr *p = __DTOR_LIST__ + 1;
 307     func_ptr f;
 308
 309     while ((f = *p))
 310       {
 311         p++;
 312         f ();
 313       }
 314   }
 315 #endif /* !defined(FINI_ARRAY_SECTION_ASM_OP) */
 316
 317 #ifdef USE_EH_FRAME_REGISTRY
 318 #ifdef CRT_GET_RFIB_DATA
 319   /* If we used the new __register_frame_info_bases interface,
 320      make sure that we deregister from the same place.  */
 321   if (__deregister_frame_info_bases)
 322     __deregister_frame_info_bases (__EH_FRAME_BEGIN__);
 323 #else
 324   if (__deregister_frame_info)
 325     __deregister_frame_info (__EH_FRAME_BEGIN__);
 326 #endif
 327 #endif
 328
 329   completed = 1;
 330 }
 331
 332 /* Stick a call to __do_global_dtors_aux into the .fini section.  */
 333 #ifdef FINI_SECTION_ASM_OP
 334 CRT_CALL_STATIC_FUNCTION (FINI_SECTION_ASM_OP, __do_global_dtors_aux)
 335 #else /* !defined(FINI_SECTION_ASM_OP) */
 336 static func_ptr __do_global_dtors_aux_fini_array_entry[]
 337   __attribute__ ((__unused__, section(".fini_array")))
 338   = { __do_global_dtors_aux };
 339 #endif /* !defined(FINI_SECTION_ASM_OP) */
 340
 341 #if defined(USE_EH_FRAME_REGISTRY) || defined(JCR_SECTION_NAME)
 342 /* Stick a call to __register_frame_info into the .init section.  For some
 343    reason calls with no arguments work more reliably in .init, so stick the
 344    call in another function.  */
 345
 346 static void __attribute__((used))
 347 frame_dummy (void)
 348 {
 349 #ifdef USE_EH_FRAME_REGISTRY
 350   static struct object object;
 351 #ifdef CRT_GET_RFIB_DATA
 352   void *tbase, *dbase;
 353   tbase = 0;
 354   CRT_GET_RFIB_DATA (dbase);
 355   if (__register_frame_info_bases)
 356     __register_frame_info_bases (__EH_FRAME_BEGIN__, &object, tbase, dbase);
 357 #else
 358   if (__register_frame_info)
 359     __register_frame_info (__EH_FRAME_BEGIN__, &object);
 360 #endif /* CRT_GET_RFIB_DATA */
 361 #endif /* USE_EH_FRAME_REGISTRY */
 362 #ifdef JCR_SECTION_NAME
 363   if (__JCR_LIST__[0])
 364     {
 365       void (*register_classes) (void *) = _Jv_RegisterClasses;
 366       __asm ("" : "+r" (register_classes));
 367       if (register_classes)
 368         register_classes (__JCR_LIST__);
 369     }
 370 #endif /* JCR_SECTION_NAME */
 371 }
 372
 373 #ifdef INIT_SECTION_ASM_OP
 374 CRT_CALL_STATIC_FUNCTION (INIT_SECTION_ASM_OP, frame_dummy)
 375 #else /* defined(INIT_SECTION_ASM_OP) */
 376 static func_ptr __frame_dummy_init_array_entry[]
 377   __attribute__ ((__unused__, section(".init_array")))
 378   = { frame_dummy };
 379 #endif /* !defined(INIT_SECTION_ASM_OP) */
 380 #endif /* USE_EH_FRAME_REGISTRY || JCR_SECTION_NAME */
 381
 382 #else  /* OBJECT_FORMAT_ELF */
 383
 384 /* The function __do_global_ctors_aux is compiled twice (once in crtbegin.o
 385    and once in crtend.o).  It must be declared static to avoid a link
 386    error.  Here, we define __do_global_ctors as an externally callable
 387    function.  It is externally callable so that __main can invoke it when
 388    INVOKE__main is defined.  This has the additional effect of forcing cc1
 389    to switch to the .text section.  */
 390
 391 static void __do_global_ctors_aux (void);
 392 void
 393 __do_global_ctors (void)
 394 {
 395 #ifdef INVOKE__main
 396   /* If __main won't actually call __do_global_ctors then it doesn't matter
 397      what's inside the function.  The inside of __do_global_ctors_aux is
 398      called automatically in that case.  And the Alliant fx2800 linker
 399      crashes on this reference.  So prevent the crash.  */
 400   __do_global_ctors_aux ();
 401 #endif
 402 }
 403
 404 asm (INIT_SECTION_ASM_OP);      /* cc1 doesn't know that we are switching! */
 405
 406 /* A routine to invoke all of the global constructors upon entry to the
 407    program.  We put this into the .init section (for systems that have
 408    such a thing) so that we can properly perform the construction of
 409    file-scope static-storage C++ objects within shared libraries.  */
 410
 411 static void __attribute__((used))
 412 __do_global_ctors_aux (void)    /* prologue goes in .init section */
 413 {
 414   FORCE_CODE_SECTION_ALIGN      /* explicit align before switch to .text */
 415   asm (TEXT_SECTION_ASM_OP);    /* don't put epilogue and body in .init */
 416   DO_GLOBAL_CTORS_BODY;
 417   atexit (__do_global_dtors);
 418 }
 419
 420 #endif /* OBJECT_FORMAT_ELF */
 421
 422 #elif defined(HAS_INIT_SECTION) /* ! INIT_SECTION_ASM_OP */
 423
 424 extern void __do_global_dtors (void);
 425
 426 /* This case is used by the Irix 6 port, which supports named sections but
 427    not an SVR4-style .fini section.  __do_global_dtors can be non-static
 428    in this case because we protect it with -hidden_symbol.  */
 429
 430 void
 431 __do_global_dtors (void)
 432 {
 433   func_ptr *p, f;
 434   for (p = __DTOR_LIST__ + 1; (f = *p); p++)
 435     f ();
 436
 437 #ifdef USE_EH_FRAME_REGISTRY
 438   if (__deregister_frame_info)
 439     __deregister_frame_info (__EH_FRAME_BEGIN__);
 440 #endif
 441 }
 442
 443 #if defined(USE_EH_FRAME_REGISTRY) || defined(JCR_SECTION_NAME)
 444 /* A helper function for __do_global_ctors, which is in crtend.o.  Here
 445    in crtbegin.o, we can reference a couple of symbols not visible there.
 446    Plus, since we're before libgcc.a, we have no problems referencing
 447    functions from there.  */
 448 void
 449 __do_global_ctors_1(void)
 450 {
 451 #ifdef USE_EH_FRAME_REGISTRY
 452   static struct object object;
 453   if (__register_frame_info)
 454     __register_frame_info (__EH_FRAME_BEGIN__, &object);
 455 #endif
 456 #ifdef JCR_SECTION_NAME
 457   if (__JCR_LIST__[0])
 458     {
 459       void (*register_classes) (void *) = _Jv_RegisterClasses;
 460       __asm ("" : "+r" (register_classes));
 461       if (register_classes)
 462         register_classes (__JCR_LIST__);
 463     }
 464 #endif
 465 }
 466 #endif /* USE_EH_FRAME_REGISTRY || JCR_SECTION_NAME */
 467
 468 #else /* ! INIT_SECTION_ASM_OP && ! HAS_INIT_SECTION */
 469 #error "What are you doing with crtstuff.c, then?"
 470 #endif
 471
 472 #elif defined(CRT_END) /* ! CRT_BEGIN */
 473
 474 /* Put a word containing zero at the end of each of our two lists of function
 475    addresses.  Note that the words defined here go into the .ctors and .dtors
 476    sections of the crtend.o file, and since that file is always linked in
 477    last, these words naturally end up at the very ends of the two lists
 478    contained in these two sections.  */
 479
 480 #ifdef CTOR_LIST_END
 481 CTOR_LIST_END;
 482 #elif defined(CTORS_SECTION_ASM_OP)
 483 /* Hack: force cc1 to switch to .data section early, so that assembling
 484    __CTOR_LIST__ does not undo our behind-the-back change to .ctors.  */
 485 static func_ptr force_to_data[1] __attribute__ ((__unused__)) = { };
 486 asm (CTORS_SECTION_ASM_OP);
 487 STATIC func_ptr __CTOR_END__[1]
 488   __attribute__((aligned(sizeof(func_ptr))))
 489   = { (func_ptr) 0 };
 490 #else
 491 STATIC func_ptr __CTOR_END__[1]
 492   __attribute__((section(".ctors"), aligned(sizeof(func_ptr))))
 493   = { (func_ptr) 0 };
 494 #endif
 495
 496 #ifdef DTOR_LIST_END
 497 DTOR_LIST_END;
 498 #elif defined(HIDDEN_DTOR_LIST_END)
 499 #ifdef DTORS_SECTION_ASM_OP
 500 asm (DTORS_SECTION_ASM_OP);
 501 #endif
 502 func_ptr __DTOR_END__[1]
 503   __attribute__ ((unused,
 504 #ifndef DTORS_SECTION_ASM_OP
 505                   section(".dtors"),
 506 #endif
 507                   aligned(sizeof(func_ptr)), visibility ("hidden")))
 508   = { (func_ptr) 0 };
 509 #elif defined(DTORS_SECTION_ASM_OP)
 510 asm (DTORS_SECTION_ASM_OP);
 511 STATIC func_ptr __DTOR_END__[1]
 512   __attribute__ ((unused, aligned(sizeof(func_ptr))))
 513   = { (func_ptr) 0 };
 514 #else
 515 STATIC func_ptr __DTOR_END__[1]
 516   __attribute__((unused, section(".dtors"), aligned(sizeof(func_ptr))))
 517   = { (func_ptr) 0 };
 518 #endif
 519
 520 #ifdef EH_FRAME_SECTION_NAME
 521 /* Terminate the frame unwind info section with a 4byte 0 as a sentinel;
 522    this would be the 'length' field in a real FDE.  */
 523 # if __INT_MAX__ == 2147483647
 524 typedef int int32;
 525 # elif __LONG_MAX__ == 2147483647
 526 typedef long int32;
 527 # elif __SHRT_MAX__ == 2147483647
 528 typedef short int32;
 529 # else
 530 #  error "Missing a 4 byte integer"
 531 # endif
 532 STATIC EH_FRAME_SECTION_CONST int32 __FRAME_END__[]
 533      __attribute__ ((unused, section(EH_FRAME_SECTION_NAME),
 534                      aligned(sizeof(int32))))
 535      = { 0 };
 536 #endif /* EH_FRAME_SECTION_NAME */
 537
 538 #ifdef JCR_SECTION_NAME
 539 /* Null terminate the .jcr section array.  */
 540 STATIC void *__JCR_END__[1]
 541    __attribute__ ((unused, section(JCR_SECTION_NAME),
 542                    aligned(sizeof(void *))))
 543    = { 0 };
 544 #endif /* JCR_SECTION_NAME */
 545
 546 #ifdef INIT_ARRAY_SECTION_ASM_OP
 547
 548 /* If we are using .init_array, there is nothing to do.  */
 549
 550 #elif defined(INIT_SECTION_ASM_OP)
 551
 552 #ifdef OBJECT_FORMAT_ELF
 553 static void __attribute__((used))
 554 __do_global_ctors_aux (void)
 555 {
 556   func_ptr *p;
 557   for (p = __CTOR_END__ - 1; *p != (func_ptr) -1; p--)
 558     (*p) ();
 559 }
 560
 561 /* Stick a call to __do_global_ctors_aux into the .init section.  */
 562 CRT_CALL_STATIC_FUNCTION (INIT_SECTION_ASM_OP, __do_global_ctors_aux)
 563 #else  /* OBJECT_FORMAT_ELF */
 564
 565 /* Stick the real initialization code, followed by a normal sort of
 566    function epilogue at the very end of the .init section for this
 567    entire root executable file or for this entire shared library file.
 568
 569    Note that we use some tricks here to get *just* the body and just
 570    a function epilogue (but no function prologue) into the .init
 571    section of the crtend.o file.  Specifically, we switch to the .text
 572    section, start to define a function, and then we switch to the .init
 573    section just before the body code.
 574
 575    Earlier on, we put the corresponding function prologue into the .init
 576    section of the crtbegin.o file (which will be linked in first).
 577
 578    Note that we want to invoke all constructors for C++ file-scope static-
 579    storage objects AFTER any other possible initialization actions which
 580    may be performed by the code in the .init section contributions made by
 581    other libraries, etc.  That's because those other initializations may
 582    include setup operations for very primitive things (e.g. initializing
 583    the state of the floating-point coprocessor, etc.) which should be done
 584    before we start to execute any of the user's code.  */
 585
 586 static void
 587 __do_global_ctors_aux (void)    /* prologue goes in .text section */
 588 {
 589   asm (INIT_SECTION_ASM_OP);
 590   DO_GLOBAL_CTORS_BODY;
 591   atexit (__do_global_dtors);
 592 }                               /* epilogue and body go in .init section */
 593
 594 FORCE_CODE_SECTION_ALIGN
 595 asm (TEXT_SECTION_ASM_OP);
 596
 597 #endif /* OBJECT_FORMAT_ELF */
 598
 599 #elif defined(HAS_INIT_SECTION) /* ! INIT_SECTION_ASM_OP */
 600
 601 extern void __do_global_ctors (void);
 602
 603 /* This case is used by the Irix 6 port, which supports named sections but
 604    not an SVR4-style .init section.  __do_global_ctors can be non-static
 605    in this case because we protect it with -hidden_symbol.  */
 606 void
 607 __do_global_ctors (void)
 608 {
 609   func_ptr *p;
 610 #if defined(USE_EH_FRAME_REGISTRY) || defined(JCR_SECTION_NAME)
 611   __do_global_ctors_1();
 612 #endif
 613   for (p = __CTOR_END__ - 1; *p != (func_ptr) -1; p--)
 614     (*p) ();
 615 }
 616
 617 #else /* ! INIT_SECTION_ASM_OP && ! HAS_INIT_SECTION */
 618 #error "What are you doing with crtstuff.c, then?"
 619 #endif
 620
 621 #else /* ! CRT_BEGIN && ! CRT_END */
 622 #error "One of CRT_BEGIN or CRT_END must be defined."
 623 #endif