libgcc/config/darwin-crt3.c

   1 /* __cxa_atexit backwards-compatibility support for Darwin.
   2    Copyright (C) 2006-2022 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 /* Don't do anything if we are compiling for a kext multilib. */
  26 #ifdef __PIC__
  27
  28 #include "tconfig.h"
  29 #include "tsystem.h"
  30
  31 #include <dlfcn.h>
  32 #include <stdbool.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 /* This file works around two different problems.
  37
  38    The first problem is that there is no __cxa_atexit on Mac OS versions
  39    before 10.4.  It fixes this by providing a complete atexit and
  40    __cxa_atexit emulation called from the regular atexit.
  41
  42    The second problem is that on all shipping versions of Mac OS,
  43    __cxa_finalize and exit() don't work right: they don't run routines
  44    that were registered while other atexit routines are running.  This
  45    is worked around by wrapping each atexit/__cxa_atexit routine with
  46    our own routine which ensures that any __cxa_atexit calls while it
  47    is running are honoured.
  48
  49    There are still problems which this does not solve.  Before 10.4,
  50    shared objects linked with previous compilers won't have their
  51    atexit calls properly interleaved with code compiled with newer
  52    compilers.  Also, atexit routines registered from shared objects
  53    linked with previous compilers won't get the bug fix.  */
  54
  55 typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, const void* dso);
  56 typedef void (*cxa_finalize_p)(const void *dso);
  57 typedef int (*atexit_p)(void (*func)(void));
  58
  59 /* These are from "keymgr.h".  */
  60 extern void *_keymgr_get_and_lock_processwide_ptr (unsigned key);
  61 extern int _keymgr_get_and_lock_processwide_ptr_2 (unsigned, void **);
  62 extern int _keymgr_set_and_unlock_processwide_ptr (unsigned key, void *ptr);
  63
  64 extern void *__keymgr_global[];
  65 typedef struct _Sinfo_Node {
  66         unsigned int size ;             /*size of this node*/
  67         unsigned short major_version ;  /*API major version.*/
  68         unsigned short minor_version ;  /*API minor version.*/
  69         } _Tinfo_Node ;
  70
  71 #ifdef __ppc__
  72 #define CHECK_KEYMGR_ERROR(e) \
  73   (((_Tinfo_Node *)__keymgr_global[2])->major_version >= 4 ? (e) : 0)
  74 #else
  75 #define CHECK_KEYMGR_ERROR(e) (e)
  76 #endif
  77
  78 /* Our globals are stored under this keymgr index.  */
  79 #define KEYMGR_ATEXIT_LIST      14
  80
  81 /* The different kinds of callback routines.  */
  82 typedef void (*atexit_callback)(void);
  83 typedef void (*cxa_atexit_callback)(void *);
  84
  85 /* This structure holds a routine to call.  There may be extra fields
  86    at the end of the structure that this code doesn't know about.  */
  87 struct one_atexit_routine
  88 {
  89   union {
  90     atexit_callback ac;
  91     cxa_atexit_callback cac;
  92   } callback;
  93   /* has_arg is 0/2/4 if 'ac' is live, 1/3/5 if 'cac' is live.
  94      Higher numbers indicate a later version of the structure that this
  95      code doesn't understand and will ignore.  */
  96   int has_arg;
  97   void * arg;
  98 };
  99
 100 struct atexit_routine_list
 101 {
 102   struct atexit_routine_list * next;
 103   struct one_atexit_routine r;
 104 };
 105
 106 /* The various possibilities for status of atexit().  */
 107 enum atexit_status {
 108   atexit_status_unknown = 0,
 109   atexit_status_missing = 1,
 110   atexit_status_broken = 2,
 111   atexit_status_working = 16
 112 };
 113
 114 struct keymgr_atexit_list
 115 {
 116   /* Version of this list.  This code knows only about version 0.
 117      If the version is higher than 0, this code may add new atexit routines
 118      but should not attempt to run the list.  */
 119   short version;
 120   /* 1 if an atexit routine is currently being run by this code, 0
 121      otherwise.  */
 122   char running_routines;
 123   /* Holds a value from 'enum atexit_status'.  */
 124   unsigned char atexit_status;
 125   /* The list of atexit and cxa_atexit routines registered.  If
 126    atexit_status_missing it contains all routines registered while
 127    linked with this code.  If atexit_status_broken it contains all
 128    routines registered during cxa_finalize while linked with this
 129    code.  */
 130   struct atexit_routine_list *l;
 131   /* &__cxa_atexit; set if atexit_status >= atexit_status_broken.  */
 132   cxa_atexit_p cxa_atexit_f;
 133   /* &__cxa_finalize; set if atexit_status >= atexit_status_broken.  */
 134   cxa_finalize_p cxa_finalize_f;
 135   /* &atexit; set if atexit_status >= atexit_status_working
 136      or atexit_status == atexit_status_missing.  */
 137   atexit_p atexit_f;
 138 };
 139
 140 /* Return 0 if __cxa_atexit has the bug it has in Mac OS 10.4: it
 141    fails to call routines registered while an atexit routine is
 142    running.  Return 1 if it works properly, and -1 if an error occurred.  */
 143
 144 struct atexit_data
 145 {
 146   int result;
 147   cxa_atexit_p cxa_atexit;
 148 };
 149
 150 static void cxa_atexit_check_2 (void *arg)
 151 {
 152   ((struct atexit_data *)arg)->result = 1;
 153 }
 154
 155 static void cxa_atexit_check_1 (void *arg)
 156 {
 157   struct atexit_data * aed = arg;
 158   if (aed->cxa_atexit (cxa_atexit_check_2, arg, arg) != 0)
 159     aed->result = -1;
 160 }
 161
 162 static int
 163 check_cxa_atexit (cxa_atexit_p cxa_atexit, cxa_finalize_p cxa_finalize)
 164 {
 165   struct atexit_data aed = { 0, cxa_atexit };
 166
 167   /* We re-use &aed as the 'dso' parameter, since it's a unique address.  */
 168   if (cxa_atexit (cxa_atexit_check_1, &aed, &aed) != 0)
 169     return -1;
 170   cxa_finalize (&aed);
 171   if (aed.result == 0)
 172     {
 173       /* Call __cxa_finalize again to make sure that cxa_atexit_check_2
 174          is removed from the list before AED goes out of scope.  */
 175       cxa_finalize (&aed);
 176       aed.result = 0;
 177     }
 178   return aed.result;
 179 }
 180
 181 #ifdef __ppc__
 182 /* This comes from Csu.  It works only before 10.4.  The prototype has
 183    been altered a bit to avoid casting.  */
 184 extern int _dyld_func_lookup(const char *dyld_func_name,
 185      void *address) __attribute__((visibility("hidden")));
 186
 187 static void our_atexit (void);
 188
 189 /* We're running on 10.3.9.  Find the address of the system atexit()
 190    function.  So easy to say, so hard to do.  */
 191 static atexit_p
 192 find_atexit_10_3 (void)
 193 {
 194   unsigned int (*dyld_image_count_fn)(void);
 195   const char *(*dyld_get_image_name_fn)(unsigned int image_index);
 196   const void *(*dyld_get_image_header_fn)(unsigned int image_index);
 197   const void *(*NSLookupSymbolInImage_fn)(const void *image,
 198                                           const char *symbolName,
 199                                           unsigned int options);
 200   void *(*NSAddressOfSymbol_fn)(const void *symbol);
 201   unsigned i, count;
 202
 203   /* Find some dyld functions.  */
 204   _dyld_func_lookup("__dyld_image_count", &dyld_image_count_fn);
 205   _dyld_func_lookup("__dyld_get_image_name", &dyld_get_image_name_fn);
 206   _dyld_func_lookup("__dyld_get_image_header", &dyld_get_image_header_fn);
 207   _dyld_func_lookup("__dyld_NSLookupSymbolInImage", &NSLookupSymbolInImage_fn);
 208   _dyld_func_lookup("__dyld_NSAddressOfSymbol", &NSAddressOfSymbol_fn);
 209
 210   /* If any of these don't exist, that's an error.  */
 211   if (! dyld_image_count_fn || ! dyld_get_image_name_fn
 212       || ! dyld_get_image_header_fn || ! NSLookupSymbolInImage_fn
 213       || ! NSAddressOfSymbol_fn)
 214     return NULL;
 215
 216   count = dyld_image_count_fn ();
 217   for (i = 0; i < count; i++)
 218     {
 219       const char * path = dyld_get_image_name_fn (i);
 220       const void * image;
 221       const void * symbol;
 222
 223       if (strcmp (path, "/usr/lib/libSystem.B.dylib") != 0)
 224         continue;
 225       image = dyld_get_image_header_fn (i);
 226       if (! image)
 227         return NULL;
 228       /* '4' is NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR.  */
 229       symbol = NSLookupSymbolInImage_fn (image, "_atexit", 4);
 230       if (! symbol)
 231         return NULL;
 232       return NSAddressOfSymbol_fn (symbol);
 233     }
 234   return NULL;
 235 }
 236 #endif
 237
 238 /* Create (if necessary), find, lock, fill in, and return our globals.
 239    Return NULL on error, in which case the globals will not be locked.
 240    The caller should call keymgr_set_and_unlock.  */
 241 static struct keymgr_atexit_list *
 242 get_globals (void)
 243 {
 244   struct keymgr_atexit_list * r;
 245
 246 #ifdef __ppc__
 247   /* 10.3.9 doesn't have _keymgr_get_and_lock_processwide_ptr_2 so the
 248      PPC side can't use it.  On 10.4 this just means the error gets
 249      reported a little later when
 250      _keymgr_set_and_unlock_processwide_ptr finds that the key was
 251      never locked.  */
 252   r = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
 253 #else
 254   void * rr;
 255   if (_keymgr_get_and_lock_processwide_ptr_2 (KEYMGR_ATEXIT_LIST, &rr))
 256     return NULL;
 257   r = rr;
 258 #endif
 259
 260   if (r == NULL)
 261     {
 262       r = calloc (sizeof (struct keymgr_atexit_list), 1);
 263       if (! r)
 264         return NULL;
 265     }
 266
 267   if (r->atexit_status == atexit_status_unknown)
 268     {
 269       void *handle;
 270
 271       handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
 272       if (!handle)
 273         {
 274 #ifdef __ppc__
 275           r->atexit_status = atexit_status_missing;
 276           r->atexit_f = find_atexit_10_3 ();
 277           if (! r->atexit_f)
 278             goto error;
 279           if (r->atexit_f (our_atexit))
 280             goto error;
 281 #else
 282           goto error;
 283 #endif
 284         }
 285       else
 286         {
 287           int chk_result;
 288
 289           r->cxa_atexit_f = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
 290           r->cxa_finalize_f = (cxa_finalize_p)dlsym (handle, "__cxa_finalize");
 291           if (! r->cxa_atexit_f || ! r->cxa_finalize_f)
 292             goto error;
 293
 294           chk_result = check_cxa_atexit (r->cxa_atexit_f, r->cxa_finalize_f);
 295           if (chk_result == -1)
 296             goto error;
 297           else if (chk_result == 0)
 298             r->atexit_status = atexit_status_broken;
 299           else
 300             {
 301               r->atexit_f = (atexit_p)dlsym (handle, "atexit");
 302               if (! r->atexit_f)
 303                 goto error;
 304               r->atexit_status = atexit_status_working;
 305             }
 306         }
 307     }
 308
 309   return r;
 310
 311  error:
 312   _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, r);
 313   return NULL;
 314 }
 315
 316 /* Add TO_ADD to ATEXIT_LIST.  ATEXIT_LIST may be NULL but is
 317    always the result of calling _keymgr_get_and_lock_processwide_ptr and
 318    so KEYMGR_ATEXIT_LIST is known to be locked; this routine is responsible
 319    for unlocking it.  */
 320
 321 static int
 322 add_routine (struct keymgr_atexit_list * g,
 323              const struct one_atexit_routine * to_add)
 324 {
 325   struct atexit_routine_list * s
 326     = malloc (sizeof (struct atexit_routine_list));
 327   int result;
 328
 329   if (!s)
 330     {
 331       _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 332       return -1;
 333     }
 334   s->r = *to_add;
 335   s->next = g->l;
 336   g->l = s;
 337   result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 338   return CHECK_KEYMGR_ERROR (result) == 0 ? 0 : -1;
 339 }
 340
 341 /* This runs the routines in G->L up to STOP.  */
 342 static struct keymgr_atexit_list *
 343 run_routines (struct keymgr_atexit_list *g,
 344               struct atexit_routine_list *stop)
 345 {
 346   for (;;)
 347     {
 348       struct atexit_routine_list * cur = g->l;
 349       if (! cur || cur == stop)
 350         break;
 351       g->l = cur->next;
 352       _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 353
 354       switch (cur->r.has_arg) {
 355       case 0: case 2: case 4:
 356         cur->r.callback.ac ();
 357         break;
 358       case 1: case 3: case 5:
 359         cur->r.callback.cac (cur->r.arg);
 360         break;
 361       default:
 362         /* Don't understand, so don't call it.  */
 363         break;
 364       }
 365       free (cur);
 366
 367       g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
 368       if (! g)
 369         break;
 370     }
 371   return g;
 372 }
 373
 374 /* Call the routine described by ROUTINE_PARAM and then call any
 375    routines added to KEYMGR_ATEXIT_LIST while that routine was
 376    running, all with in_cxa_finalize set.  */
 377
 378 static void
 379 cxa_atexit_wrapper (void* routine_param)
 380 {
 381   struct one_atexit_routine * routine = routine_param;
 382   struct keymgr_atexit_list *g;
 383   struct atexit_routine_list * base = NULL;
 384   char prev_running = 0;
 385
 386   g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
 387   if (g)
 388     {
 389       prev_running = g->running_routines;
 390       g->running_routines = 1;
 391       base = g->l;
 392       _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 393     }
 394
 395   if (routine->has_arg)
 396     routine->callback.cac (routine->arg);
 397   else
 398     routine->callback.ac ();
 399
 400   if (g)
 401     g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
 402   if (g)
 403     g = run_routines (g, base);
 404   if (g)
 405     {
 406       g->running_routines = prev_running;
 407       _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 408     }
 409 }
 410
 411 #ifdef __ppc__
 412 /* This code is used while running on 10.3.9, when __cxa_atexit doesn't
 413    exist in the system library.  10.3.9 only supported regular PowerPC,
 414    so this code isn't necessary on x86 or ppc64.  */
 415
 416 /* This routine is called from the system atexit(); it runs everything
 417    registered on the KEYMGR_ATEXIT_LIST.  */
 418
 419 static void
 420 our_atexit (void)
 421 {
 422   struct keymgr_atexit_list *g;
 423   char prev_running;
 424
 425   g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
 426   if (! g || g->version != 0 || g->atexit_status != atexit_status_missing)
 427     return;
 428
 429   prev_running = g->running_routines;
 430   g->running_routines = 1;
 431   g = run_routines (g, NULL);
 432   if (! g)
 433     return;
 434   g->running_routines = prev_running;
 435   _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 436 }
 437 #endif
 438
 439 /* This is our wrapper around atexit and __cxa_atexit.  It will return
 440    nonzero if an error occurs, and otherwise:
 441    - if in_cxa_finalize is set, or running on 10.3.9, add R to
 442      KEYMGR_ATEXIT_LIST; or
 443    - call the system __cxa_atexit to add cxa_atexit_wrapper with an argument
 444      that indicates how cxa_atexit_wrapper should call R.  */
 445
 446 static int
 447 atexit_common (const struct one_atexit_routine *r, const void *dso)
 448 {
 449   struct keymgr_atexit_list *g = get_globals ();
 450
 451   if (! g)
 452     return -1;
 453
 454   if (g->running_routines || g->atexit_status == atexit_status_missing)
 455     return add_routine (g, r);
 456
 457   if (g->atexit_status >= atexit_status_working)
 458     {
 459       int result;
 460       if (r->has_arg)
 461         {
 462           cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
 463           result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
 464                                                            g);
 465           if (CHECK_KEYMGR_ERROR (result))
 466             return -1;
 467           return cxa_atexit (r->callback.cac, r->arg, dso);
 468         }
 469       else
 470         {
 471           atexit_p atexit_f = g->atexit_f;
 472           result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
 473                                                            g);
 474           if (CHECK_KEYMGR_ERROR (result))
 475             return -1;
 476           return atexit_f (r->callback.ac);
 477         }
 478     }
 479   else
 480     {
 481       cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
 482       struct one_atexit_routine *alloced;
 483       int result;
 484
 485       result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
 486       if (CHECK_KEYMGR_ERROR (result))
 487         return -1;
 488
 489       alloced = malloc (sizeof (struct one_atexit_routine));
 490       if (! alloced)
 491         return -1;
 492       *alloced = *r;
 493       return cxa_atexit (cxa_atexit_wrapper, alloced, dso);
 494     }
 495 }
 496
 497 /* These are the actual replacement routines; they just funnel into
 498    atexit_common.  */
 499
 500 int __cxa_atexit (cxa_atexit_callback func, void* arg,
 501                   const void* dso) __attribute__((visibility("hidden")));
 502
 503 int
 504 __cxa_atexit (cxa_atexit_callback func, void* arg, const void* dso)
 505 {
 506   struct one_atexit_routine r;
 507   r.callback.cac = func;
 508   r.has_arg = 1;
 509   r.arg = arg;
 510   return atexit_common (&r, dso);
 511 }
 512
 513 int atexit (atexit_callback func) __attribute__((visibility("hidden")));
 514
 515 /* Use __dso_handle to allow even bundles that call atexit() to be unloaded
 516    on 10.4.  */
 517 extern void __dso_handle;
 518
 519 int
 520 atexit (atexit_callback func)
 521 {
 522   struct one_atexit_routine r;
 523   r.callback.ac = func;
 524   r.has_arg = 0;
 525   return atexit_common (&r, &__dso_handle);
 526 }
 527
 528 #endif /* __PIC__ */