gdb/ia64-libunwind-tdep.c

   1 /* Frame unwinder for ia64 frames using the libunwind library.
   2
   3    Copyright (C) 2003-2017 Free Software Foundation, Inc.
   4
   5    Written by Jeff Johnston, contributed by Red Hat Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23
  24 #include "inferior.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "symtab.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33
  34 #include <dlfcn.h>
  35
  36 #include "ia64-libunwind-tdep.h"
  37
  38 #include "complaints.h"
  39
  40 /* IA-64 is the only target that currently uses ia64-libunwind-tdep.
  41    Note how UNW_TARGET, UNW_OBJ, etc. are compile time constants below.
  42    Those come from libunwind's headers, and are target dependent.
  43    Also, some of libunwind's typedefs are target dependent, as e.g.,
  44    unw_word_t.  If some other target wants to use this, we will need
  45    to do some abstracting in order to make it possible to select which
  46    libunwind we're talking to at runtime (and have one per arch).  */
  47
  48 /* The following two macros are normally defined in <endian.h>.
  49    But systems such as ia64-hpux do not provide such header, so
  50    we just define them here if not already defined.  */
  51 #ifndef __LITTLE_ENDIAN
  52 #define __LITTLE_ENDIAN 1234
  53 #endif
  54 #ifndef __BIG_ENDIAN
  55 #define __BIG_ENDIAN    4321
  56 #endif
  57
  58 static int libunwind_initialized;
  59 static struct gdbarch_data *libunwind_descr_handle;
  60
  61 /* Required function pointers from libunwind.  */
  62 typedef int (unw_get_reg_p_ftype) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  63 static unw_get_reg_p_ftype *unw_get_reg_p;
  64 typedef int (unw_get_fpreg_p_ftype) (unw_cursor_t *, unw_regnum_t,
  65                                      unw_fpreg_t *);
  66 static unw_get_fpreg_p_ftype *unw_get_fpreg_p;
  67 typedef int (unw_get_saveloc_p_ftype) (unw_cursor_t *, unw_regnum_t,
  68                                        unw_save_loc_t *);
  69 static unw_get_saveloc_p_ftype *unw_get_saveloc_p;
  70 typedef int (unw_is_signal_frame_p_ftype) (unw_cursor_t *);
  71 static unw_is_signal_frame_p_ftype *unw_is_signal_frame_p;
  72 typedef int (unw_step_p_ftype) (unw_cursor_t *);
  73 static unw_step_p_ftype *unw_step_p;
  74 typedef int (unw_init_remote_p_ftype) (unw_cursor_t *, unw_addr_space_t,
  75                                        void *);
  76 static unw_init_remote_p_ftype *unw_init_remote_p;
  77 typedef unw_addr_space_t (unw_create_addr_space_p_ftype) (unw_accessors_t *,
  78                                                           int);
  79 static unw_create_addr_space_p_ftype *unw_create_addr_space_p;
  80 typedef void (unw_destroy_addr_space_p_ftype) (unw_addr_space_t);
  81 static unw_destroy_addr_space_p_ftype *unw_destroy_addr_space_p;
  82 typedef int (unw_search_unwind_table_p_ftype) (unw_addr_space_t, unw_word_t,
  83                                                unw_dyn_info_t *,
  84                                                unw_proc_info_t *, int, void *);
  85 static unw_search_unwind_table_p_ftype *unw_search_unwind_table_p;
  86 typedef unw_word_t (unw_find_dyn_list_p_ftype) (unw_addr_space_t,
  87                                                 unw_dyn_info_t *, void *);
  88 static unw_find_dyn_list_p_ftype *unw_find_dyn_list_p;
  89
  90
  91 struct libunwind_frame_cache
  92 {
  93   CORE_ADDR base;
  94   CORE_ADDR func_addr;
  95   unw_cursor_t cursor;
  96   unw_addr_space_t as;
  97 };
  98
  99 /* We need to qualify the function names with a platform-specific prefix
 100    to match the names used by the libunwind library.  The UNW_OBJ macro is
 101    provided by the libunwind.h header file.  */
 102 #define STRINGIFY2(name)        #name
 103 #define STRINGIFY(name)         STRINGIFY2(name)
 104
 105 #ifndef LIBUNWIND_SO
 106 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
 107    only library, not a runtime one.  */
 108 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
 109
 110 /* Provide also compatibility with older .so.  The two APIs are compatible, .8
 111    is only extended a bit, GDB does not use the extended API at all.  */
 112 #define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
 113 #endif
 114
 115 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
 116 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
 117 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
 118 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
 119 static char *step_name = STRINGIFY(UNW_OBJ(step));
 120 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
 121 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
 122 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
 123 static char *search_unwind_table_name
 124   = STRINGIFY(UNW_OBJ(search_unwind_table));
 125 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
 126
 127 static struct libunwind_descr *
 128 libunwind_descr (struct gdbarch *gdbarch)
 129 {
 130   return ((struct libunwind_descr *)
 131           gdbarch_data (gdbarch, libunwind_descr_handle));
 132 }
 133
 134 static void *
 135 libunwind_descr_init (struct gdbarch *gdbarch)
 136 {
 137   struct libunwind_descr *descr
 138     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
 139
 140   return descr;
 141 }
 142
 143 void
 144 libunwind_frame_set_descr (struct gdbarch *gdbarch,
 145                            struct libunwind_descr *descr)
 146 {
 147   struct libunwind_descr *arch_descr;
 148
 149   gdb_assert (gdbarch != NULL);
 150
 151   arch_descr = ((struct libunwind_descr *)
 152                 gdbarch_data (gdbarch, libunwind_descr_handle));
 153
 154   if (arch_descr == NULL)
 155     {
 156       /* First time here.  Must initialize data area.  */
 157       arch_descr = (struct libunwind_descr *) libunwind_descr_init (gdbarch);
 158       deprecated_set_gdbarch_data (gdbarch,
 159                                    libunwind_descr_handle, arch_descr);
 160     }
 161
 162   /* Copy new descriptor info into arch descriptor.  */
 163   arch_descr->gdb2uw = descr->gdb2uw;
 164   arch_descr->uw2gdb = descr->uw2gdb;
 165   arch_descr->is_fpreg = descr->is_fpreg;
 166   arch_descr->accessors = descr->accessors;
 167   arch_descr->special_accessors = descr->special_accessors;
 168 }
 169
 170 static struct libunwind_frame_cache *
 171 libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
 172 {
 173   unw_accessors_t *acc;
 174   unw_addr_space_t as;
 175   unw_word_t fp;
 176   unw_regnum_t uw_sp_regnum;
 177   struct libunwind_frame_cache *cache;
 178   struct libunwind_descr *descr;
 179   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 180   int i, ret;
 181
 182   if (*this_cache)
 183     return (struct libunwind_frame_cache *) *this_cache;
 184
 185   /* Allocate a new cache.  */
 186   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 187
 188   cache->func_addr = get_frame_func (this_frame);
 189   if (cache->func_addr == 0)
 190     /* This can happen when the frame corresponds to a function for which
 191        there is no debugging information nor any entry in the symbol table.
 192        This is probably a static function for which an entry in the symbol
 193        table was not created when the objfile got linked (observed in
 194        libpthread.so on ia64-hpux).
 195
 196        The best we can do, in that case, is use the frame PC as the function
 197        address.  We don't need to give up since we still have the unwind
 198        record to help us perform the unwinding.  There is also another
 199        compelling to continue, because abandonning now means stopping
 200        the backtrace, which can never be helpful for the user.  */
 201     cache->func_addr = get_frame_pc (this_frame);
 202
 203   /* Get a libunwind cursor to the previous frame.
 204
 205      We do this by initializing a cursor.  Libunwind treats a new cursor
 206      as the top of stack and will get the current register set via the
 207      libunwind register accessor.  Now, we provide the platform-specific
 208      accessors and we set up the register accessor to use the frame
 209      register unwinding interfaces so that we properly get the registers
 210      for the current frame rather than the top.  We then use the unw_step
 211      function to move the libunwind cursor back one frame.  We can later
 212      use this cursor to find previous registers via the unw_get_reg
 213      interface which will invoke libunwind's special logic.  */
 214   descr = libunwind_descr (gdbarch);
 215   acc = (unw_accessors_t *) descr->accessors;
 216   as =  unw_create_addr_space_p (acc,
 217                                  gdbarch_byte_order (gdbarch)
 218                                  == BFD_ENDIAN_BIG
 219                                  ? __BIG_ENDIAN
 220                                  : __LITTLE_ENDIAN);
 221
 222   unw_init_remote_p (&cache->cursor, as, this_frame);
 223   if (unw_step_p (&cache->cursor) < 0)
 224     {
 225       unw_destroy_addr_space_p (as);
 226       return NULL;
 227     }
 228
 229   /* To get base address, get sp from previous frame.  */
 230   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 231   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 232   if (ret < 0)
 233     {
 234       unw_destroy_addr_space_p (as);
 235       error (_("Can't get libunwind sp register."));
 236     }
 237
 238   cache->base = (CORE_ADDR)fp;
 239   cache->as = as;
 240
 241   *this_cache = cache;
 242   return cache;
 243 }
 244
 245 void
 246 libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
 247 {
 248   struct libunwind_frame_cache *cache
 249     = (struct libunwind_frame_cache *) this_cache;
 250
 251   if (cache->as)
 252     unw_destroy_addr_space_p (cache->as);
 253 }
 254
 255 unw_word_t
 256 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 257 {
 258   return unw_find_dyn_list_p (as, di, arg);
 259 }
 260
 261 /* Verify if there is sufficient libunwind information for the frame to use
 262    libunwind frame unwinding.  */
 263 int
 264 libunwind_frame_sniffer (const struct frame_unwind *self,
 265                          struct frame_info *this_frame, void **this_cache)
 266 {
 267   unw_cursor_t cursor;
 268   unw_accessors_t *acc;
 269   unw_addr_space_t as;
 270   struct libunwind_descr *descr;
 271   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 272   int i, ret;
 273
 274   /* To test for libunwind unwind support, initialize a cursor to
 275      the current frame and try to back up.  We use this same method
 276      when setting up the frame cache (see libunwind_frame_cache()).
 277      If libunwind returns success for this operation, it means that
 278      it has found sufficient libunwind unwinding information to do so.  */
 279
 280   descr = libunwind_descr (gdbarch);
 281   acc = (unw_accessors_t *) descr->accessors;
 282   as =  unw_create_addr_space_p (acc,
 283                                  gdbarch_byte_order (gdbarch)
 284                                  == BFD_ENDIAN_BIG
 285                                  ? __BIG_ENDIAN
 286                                  : __LITTLE_ENDIAN);
 287
 288   ret = unw_init_remote_p (&cursor, as, this_frame);
 289
 290   if (ret < 0)
 291     {
 292       unw_destroy_addr_space_p (as);
 293       return 0;
 294     }
 295
 296
 297   /* Check to see if we have libunwind info by checking if we are in a
 298      signal frame.  If it doesn't return an error, we have libunwind info
 299      and can use libunwind.  */
 300   ret = unw_is_signal_frame_p (&cursor);
 301   unw_destroy_addr_space_p (as);
 302
 303   if (ret < 0)
 304     return 0;
 305
 306   return 1;
 307 }
 308
 309 void
 310 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 311                          struct frame_id *this_id)
 312 {
 313   struct libunwind_frame_cache *cache =
 314     libunwind_frame_cache (this_frame, this_cache);
 315
 316   if (cache != NULL)
 317     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 318 }
 319
 320 struct value *
 321 libunwind_frame_prev_register (struct frame_info *this_frame,
 322                                void **this_cache, int regnum)
 323 {
 324   struct libunwind_frame_cache *cache =
 325     libunwind_frame_cache (this_frame, this_cache);
 326   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 327
 328   void *ptr;
 329   unw_cursor_t *c;
 330   unw_save_loc_t sl;
 331   int i, ret;
 332   unw_word_t intval;
 333   unw_fpreg_t fpval;
 334   unw_regnum_t uw_regnum;
 335   struct libunwind_descr *descr;
 336   struct value *val = NULL;
 337
 338   if (cache == NULL)
 339     return frame_unwind_got_constant (this_frame, regnum, 0);
 340
 341   /* Convert from gdb register number to libunwind register number.  */
 342   descr = libunwind_descr (get_frame_arch (this_frame));
 343   uw_regnum = descr->gdb2uw (regnum);
 344
 345   gdb_assert (regnum >= 0);
 346
 347   if (!target_has_registers)
 348     error (_("No registers."));
 349
 350   if (uw_regnum < 0)
 351     return frame_unwind_got_constant (this_frame, regnum, 0);
 352
 353   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 354     return frame_unwind_got_constant (this_frame, regnum, 0);
 355
 356   switch (sl.type)
 357     {
 358     case UNW_SLT_MEMORY:
 359       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 360       break;
 361
 362     case UNW_SLT_REG:
 363       val = frame_unwind_got_register (this_frame, regnum,
 364                                        descr->uw2gdb (sl.u.regnum));
 365       break;
 366     case UNW_SLT_NONE:
 367       {
 368         /* The register is not stored at a specific memory address nor
 369            inside another register.  So use libunwind to fetch the register
 370            value for us, and create a constant value with the result.  */
 371         if (descr->is_fpreg (uw_regnum))
 372           {
 373             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 374             if (ret < 0)
 375               return frame_unwind_got_constant (this_frame, regnum, 0);
 376             val = frame_unwind_got_bytes (this_frame, regnum,
 377                                           (gdb_byte *) &fpval);
 378           }
 379         else
 380           {
 381             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 382             if (ret < 0)
 383               return frame_unwind_got_constant (this_frame, regnum, 0);
 384             val = frame_unwind_got_constant (this_frame, regnum, intval);
 385           }
 386         break;
 387       }
 388     }
 389
 390   return val;
 391 }
 392
 393 /* The following is a glue routine to call the libunwind unwind table
 394    search function to get unwind information for a specified ip address.  */
 395 int
 396 libunwind_search_unwind_table (void *as, long ip, void *di,
 397                                void *pi, int need_unwind_info, void *args)
 398 {
 399   return unw_search_unwind_table_p (*(unw_addr_space_t *) as, (unw_word_t) ip,
 400                                     (unw_dyn_info_t *) di,
 401                                     (unw_proc_info_t *) pi, need_unwind_info,
 402                                     args);
 403 }
 404
 405 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 406 int
 407 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 408                                   struct frame_info *this_frame,
 409                                   void **this_cache)
 410 {
 411   unw_cursor_t cursor;
 412   unw_accessors_t *acc;
 413   unw_addr_space_t as;
 414   struct libunwind_descr *descr;
 415   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 416   int i, ret;
 417
 418   /* To test for libunwind unwind support, initialize a cursor to the
 419      current frame and try to back up.  We use this same method when
 420      setting up the frame cache (see libunwind_frame_cache()).  If
 421      libunwind returns success for this operation, it means that it
 422      has found sufficient libunwind unwinding information to do
 423      so.  */
 424
 425   descr = libunwind_descr (gdbarch);
 426   acc = (unw_accessors_t *) descr->accessors;
 427   as =  unw_create_addr_space_p (acc,
 428                                  gdbarch_byte_order (gdbarch)
 429                                  == BFD_ENDIAN_BIG
 430                                  ? __BIG_ENDIAN
 431                                  : __LITTLE_ENDIAN);
 432
 433   ret = unw_init_remote_p (&cursor, as, this_frame);
 434
 435   if (ret < 0)
 436     {
 437       unw_destroy_addr_space_p (as);
 438       return 0;
 439     }
 440
 441   /* Check to see if we are in a signal frame.  */
 442   ret = unw_is_signal_frame_p (&cursor);
 443   unw_destroy_addr_space_p (as);
 444   if (ret > 0)
 445     return 1;
 446
 447   return 0;
 448 }
 449
 450 /* The following routine is for accessing special registers of the top frame.
 451    A special set of accessors must be given that work without frame info.
 452    This is used by ia64 to access the rse registers r32-r127.  While they
 453    are usually located at BOF, this is not always true and only the libunwind
 454    info can decipher where they actually are.  */
 455 int
 456 libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
 457                            int regnum, void *buf)
 458 {
 459   unw_cursor_t cursor;
 460   unw_accessors_t *acc;
 461   unw_addr_space_t as;
 462   struct libunwind_descr *descr;
 463   int ret;
 464   unw_regnum_t uw_regnum;
 465   unw_word_t intval;
 466   unw_fpreg_t fpval;
 467   void *ptr;
 468
 469
 470   descr = libunwind_descr (gdbarch);
 471   acc = (unw_accessors_t *) descr->special_accessors;
 472   as =  unw_create_addr_space_p (acc,
 473                                  gdbarch_byte_order (gdbarch)
 474                                  == BFD_ENDIAN_BIG
 475                                  ? __BIG_ENDIAN
 476                                  : __LITTLE_ENDIAN);
 477
 478   ret = unw_init_remote_p (&cursor, as, regcache);
 479   if (ret < 0)
 480     {
 481       unw_destroy_addr_space_p (as);
 482       return -1;
 483     }
 484
 485   uw_regnum = descr->gdb2uw (regnum);
 486
 487   if (descr->is_fpreg (uw_regnum))
 488     {
 489       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 490       ptr = &fpval;
 491     }
 492   else
 493     {
 494       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 495       ptr = &intval;
 496     }
 497
 498   unw_destroy_addr_space_p (as);
 499
 500   if (ret < 0)
 501     return -1;
 502
 503   if (buf)
 504     memcpy (buf, ptr, register_size (gdbarch, regnum));
 505
 506   return 0;
 507 }
 508
 509 static int
 510 libunwind_load (void)
 511 {
 512   void *handle;
 513   char *so_error = NULL;
 514
 515   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 516   if (handle == NULL)
 517     {
 518       so_error = xstrdup (dlerror ());
 519 #ifdef LIBUNWIND_SO_7
 520       handle = dlopen (LIBUNWIND_SO_7, RTLD_NOW);
 521 #endif /* LIBUNWIND_SO_7 */
 522     }
 523   if (handle == NULL)
 524     {
 525       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 526                           LIBUNWIND_SO, so_error);
 527 #ifdef LIBUNWIND_SO_7
 528       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 529                           LIBUNWIND_SO_7, dlerror ());
 530 #endif /* LIBUNWIND_SO_7 */
 531     }
 532   xfree (so_error);
 533   if (handle == NULL)
 534     return 0;
 535
 536   /* Initialize pointers to the dynamic library functions we will use.  */
 537
 538   unw_get_reg_p = (unw_get_reg_p_ftype *) dlsym (handle, get_reg_name);
 539   if (unw_get_reg_p == NULL)
 540     return 0;
 541
 542   unw_get_fpreg_p = (unw_get_fpreg_p_ftype *) dlsym (handle, get_fpreg_name);
 543   if (unw_get_fpreg_p == NULL)
 544     return 0;
 545
 546   unw_get_saveloc_p
 547     = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name);
 548   if (unw_get_saveloc_p == NULL)
 549     return 0;
 550
 551   unw_is_signal_frame_p
 552     = (unw_is_signal_frame_p_ftype *) dlsym (handle, is_signal_frame_name);
 553   if (unw_is_signal_frame_p == NULL)
 554     return 0;
 555
 556   unw_step_p = (unw_step_p_ftype *) dlsym (handle, step_name);
 557   if (unw_step_p == NULL)
 558     return 0;
 559
 560   unw_init_remote_p
 561     = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name);
 562   if (unw_init_remote_p == NULL)
 563     return 0;
 564
 565   unw_create_addr_space_p
 566     = (unw_create_addr_space_p_ftype *) dlsym (handle, create_addr_space_name);
 567   if (unw_create_addr_space_p == NULL)
 568     return 0;
 569
 570   unw_destroy_addr_space_p
 571     = (unw_destroy_addr_space_p_ftype *) dlsym (handle,
 572                                                 destroy_addr_space_name);
 573   if (unw_destroy_addr_space_p == NULL)
 574     return 0;
 575
 576   unw_search_unwind_table_p
 577     = (unw_search_unwind_table_p_ftype *) dlsym (handle,
 578                                                  search_unwind_table_name);
 579   if (unw_search_unwind_table_p == NULL)
 580     return 0;
 581
 582   unw_find_dyn_list_p
 583     = (unw_find_dyn_list_p_ftype *) dlsym (handle, find_dyn_list_name);
 584   if (unw_find_dyn_list_p == NULL)
 585     return 0;
 586
 587   return 1;
 588 }
 589
 590 int
 591 libunwind_is_initialized (void)
 592 {
 593   return libunwind_initialized;
 594 }
 595
 596 /* Provide a prototype to silence -Wmissing-prototypes.  */
 597 void _initialize_libunwind_frame (void);
 598
 599 void
 600 _initialize_libunwind_frame (void)
 601 {
 602   libunwind_descr_handle
 603     = gdbarch_data_register_post_init (libunwind_descr_init);
 604
 605   libunwind_initialized = libunwind_load ();
 606 }