gdb/ia64-libunwind-tdep.c

   1 /* Frame unwinder for ia64 frames using the libunwind library.
   2
   3    Copyright (C) 2003-2023 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 "gdbsupport/preprocessor.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 const registry<gdbarch>::key<libunwind_descr> 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
 103 #ifndef LIBUNWIND_SO
 104 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
 105    only library, not a runtime one.  */
 106 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
 107
 108 /* Provide also compatibility with older .so.  The two APIs are compatible, .8
 109    is only extended a bit, GDB does not use the extended API at all.  */
 110 #define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
 111 #endif
 112
 113 static const char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
 114 static const char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
 115 static const char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
 116 static const char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
 117 static const char *step_name = STRINGIFY(UNW_OBJ(step));
 118 static const char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
 119 static const char *create_addr_space_name
 120   = STRINGIFY(UNW_OBJ(create_addr_space));
 121 static const char *destroy_addr_space_name
 122   = STRINGIFY(UNW_OBJ(destroy_addr_space));
 123 static const char *search_unwind_table_name
 124   = STRINGIFY(UNW_OBJ(search_unwind_table));
 125 static const 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   struct libunwind_descr *result = libunwind_descr_handle.get (gdbarch);
 131   if (result == nullptr)
 132     result = libunwind_descr_handle.emplace (gdbarch);
 133   return result;
 134 }
 135
 136 void
 137 libunwind_frame_set_descr (struct gdbarch *gdbarch,
 138                            struct libunwind_descr *descr)
 139 {
 140   struct libunwind_descr *arch_descr;
 141
 142   gdb_assert (gdbarch != NULL);
 143
 144   arch_descr = libunwind_descr (gdbarch);
 145   gdb_assert (arch_descr != NULL);
 146
 147   /* Copy new descriptor info into arch descriptor.  */
 148   arch_descr->gdb2uw = descr->gdb2uw;
 149   arch_descr->uw2gdb = descr->uw2gdb;
 150   arch_descr->is_fpreg = descr->is_fpreg;
 151   arch_descr->accessors = descr->accessors;
 152   arch_descr->special_accessors = descr->special_accessors;
 153 }
 154
 155 static struct libunwind_frame_cache *
 156 libunwind_frame_cache (frame_info_ptr this_frame, void **this_cache)
 157 {
 158   unw_accessors_t *acc;
 159   unw_addr_space_t as;
 160   unw_word_t fp;
 161   unw_regnum_t uw_sp_regnum;
 162   struct libunwind_frame_cache *cache;
 163   struct libunwind_descr *descr;
 164   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 165   int ret;
 166
 167   if (*this_cache)
 168     return (struct libunwind_frame_cache *) *this_cache;
 169
 170   /* Allocate a new cache.  */
 171   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 172
 173   cache->func_addr = get_frame_func (this_frame);
 174   if (cache->func_addr == 0)
 175     /* This can happen when the frame corresponds to a function for which
 176        there is no debugging information nor any entry in the symbol table.
 177        This is probably a static function for which an entry in the symbol
 178        table was not created when the objfile got linked (observed in
 179        libpthread.so on ia64-hpux).
 180
 181        The best we can do, in that case, is use the frame PC as the function
 182        address.  We don't need to give up since we still have the unwind
 183        record to help us perform the unwinding.  There is also another
 184        compelling to continue, because abandoning now means stopping
 185        the backtrace, which can never be helpful for the user.  */
 186     cache->func_addr = get_frame_pc (this_frame);
 187
 188   /* Get a libunwind cursor to the previous frame.
 189
 190      We do this by initializing a cursor.  Libunwind treats a new cursor
 191      as the top of stack and will get the current register set via the
 192      libunwind register accessor.  Now, we provide the platform-specific
 193      accessors and we set up the register accessor to use the frame
 194      register unwinding interfaces so that we properly get the registers
 195      for the current frame rather than the top.  We then use the unw_step
 196      function to move the libunwind cursor back one frame.  We can later
 197      use this cursor to find previous registers via the unw_get_reg
 198      interface which will invoke libunwind's special logic.  */
 199   descr = libunwind_descr (gdbarch);
 200   acc = (unw_accessors_t *) descr->accessors;
 201   as =  unw_create_addr_space_p (acc,
 202                                  gdbarch_byte_order (gdbarch)
 203                                  == BFD_ENDIAN_BIG
 204                                  ? __BIG_ENDIAN
 205                                  : __LITTLE_ENDIAN);
 206
 207   unw_init_remote_p (&cache->cursor, as, this_frame);
 208   if (unw_step_p (&cache->cursor) < 0)
 209     {
 210       unw_destroy_addr_space_p (as);
 211       return NULL;
 212     }
 213
 214   /* To get base address, get sp from previous frame.  */
 215   uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
 216   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 217   if (ret < 0)
 218     {
 219       unw_destroy_addr_space_p (as);
 220       error (_("Can't get libunwind sp register."));
 221     }
 222
 223   cache->base = (CORE_ADDR)fp;
 224   cache->as = as;
 225
 226   *this_cache = cache;
 227   return cache;
 228 }
 229
 230 void
 231 libunwind_frame_dealloc_cache (frame_info_ptr self, void *this_cache)
 232 {
 233   struct libunwind_frame_cache *cache
 234     = (struct libunwind_frame_cache *) this_cache;
 235
 236   if (cache->as)
 237     unw_destroy_addr_space_p (cache->as);
 238 }
 239
 240 unw_word_t
 241 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 242 {
 243   return unw_find_dyn_list_p (as, di, arg);
 244 }
 245
 246 /* Verify if there is sufficient libunwind information for the frame to use
 247    libunwind frame unwinding.  */
 248 int
 249 libunwind_frame_sniffer (const struct frame_unwind *self,
 250                          frame_info_ptr this_frame, void **this_cache)
 251 {
 252   unw_cursor_t cursor;
 253   unw_accessors_t *acc;
 254   unw_addr_space_t as;
 255   struct libunwind_descr *descr;
 256   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 257   int ret;
 258
 259   /* To test for libunwind unwind support, initialize a cursor to
 260      the current frame and try to back up.  We use this same method
 261      when setting up the frame cache (see libunwind_frame_cache()).
 262      If libunwind returns success for this operation, it means that
 263      it has found sufficient libunwind unwinding information to do so.  */
 264
 265   descr = libunwind_descr (gdbarch);
 266   acc = (unw_accessors_t *) descr->accessors;
 267   as =  unw_create_addr_space_p (acc,
 268                                  gdbarch_byte_order (gdbarch)
 269                                  == BFD_ENDIAN_BIG
 270                                  ? __BIG_ENDIAN
 271                                  : __LITTLE_ENDIAN);
 272
 273   ret = unw_init_remote_p (&cursor, as, this_frame);
 274
 275   if (ret < 0)
 276     {
 277       unw_destroy_addr_space_p (as);
 278       return 0;
 279     }
 280
 281
 282   /* Check to see if we have libunwind info by checking if we are in a
 283      signal frame.  If it doesn't return an error, we have libunwind info
 284      and can use libunwind.  */
 285   ret = unw_is_signal_frame_p (&cursor);
 286   unw_destroy_addr_space_p (as);
 287
 288   if (ret < 0)
 289     return 0;
 290
 291   return 1;
 292 }
 293
 294 void
 295 libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
 296                          struct frame_id *this_id)
 297 {
 298   struct libunwind_frame_cache *cache =
 299     libunwind_frame_cache (this_frame, this_cache);
 300
 301   if (cache != NULL)
 302     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 303 }
 304
 305 struct value *
 306 libunwind_frame_prev_register (frame_info_ptr this_frame,
 307                                void **this_cache, int regnum)
 308 {
 309   struct libunwind_frame_cache *cache =
 310     libunwind_frame_cache (this_frame, this_cache);
 311
 312   unw_save_loc_t sl;
 313   int ret;
 314   unw_word_t intval;
 315   unw_fpreg_t fpval;
 316   unw_regnum_t uw_regnum;
 317   struct libunwind_descr *descr;
 318   struct value *val = NULL;
 319
 320   if (cache == NULL)
 321     return frame_unwind_got_constant (this_frame, regnum, 0);
 322
 323   /* Convert from gdb register number to libunwind register number.  */
 324   descr = libunwind_descr (get_frame_arch (this_frame));
 325   uw_regnum = descr->gdb2uw (regnum);
 326
 327   gdb_assert (regnum >= 0);
 328
 329   if (!target_has_registers ())
 330     error (_("No registers."));
 331
 332   if (uw_regnum < 0)
 333     return frame_unwind_got_constant (this_frame, regnum, 0);
 334
 335   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 336     return frame_unwind_got_constant (this_frame, regnum, 0);
 337
 338   switch (sl.type)
 339     {
 340     case UNW_SLT_MEMORY:
 341       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 342       break;
 343
 344     case UNW_SLT_REG:
 345       val = frame_unwind_got_register (this_frame, regnum,
 346                                        descr->uw2gdb (sl.u.regnum));
 347       break;
 348     case UNW_SLT_NONE:
 349       {
 350         /* The register is not stored at a specific memory address nor
 351            inside another register.  So use libunwind to fetch the register
 352            value for us, and create a constant value with the result.  */
 353         if (descr->is_fpreg (uw_regnum))
 354           {
 355             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 356             if (ret < 0)
 357               return frame_unwind_got_constant (this_frame, regnum, 0);
 358             val = frame_unwind_got_bytes (this_frame, regnum,
 359                                           (gdb_byte *) &fpval);
 360           }
 361         else
 362           {
 363             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 364             if (ret < 0)
 365               return frame_unwind_got_constant (this_frame, regnum, 0);
 366             val = frame_unwind_got_constant (this_frame, regnum, intval);
 367           }
 368         break;
 369       }
 370     }
 371
 372   return val;
 373 }
 374
 375 /* The following is a glue routine to call the libunwind unwind table
 376    search function to get unwind information for a specified ip address.  */
 377 int
 378 libunwind_search_unwind_table (void *as, long ip, void *di,
 379                                void *pi, int need_unwind_info, void *args)
 380 {
 381   return unw_search_unwind_table_p (*(unw_addr_space_t *) as, (unw_word_t) ip,
 382                                     (unw_dyn_info_t *) di,
 383                                     (unw_proc_info_t *) pi, need_unwind_info,
 384                                     args);
 385 }
 386
 387 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 388 int
 389 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 390                                   frame_info_ptr this_frame,
 391                                   void **this_cache)
 392 {
 393   unw_cursor_t cursor;
 394   unw_accessors_t *acc;
 395   unw_addr_space_t as;
 396   struct libunwind_descr *descr;
 397   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 398   int ret;
 399
 400   /* To test for libunwind unwind support, initialize a cursor to the
 401      current frame and try to back up.  We use this same method when
 402      setting up the frame cache (see libunwind_frame_cache()).  If
 403      libunwind returns success for this operation, it means that it
 404      has found sufficient libunwind unwinding information to do
 405      so.  */
 406
 407   descr = libunwind_descr (gdbarch);
 408   acc = (unw_accessors_t *) descr->accessors;
 409   as =  unw_create_addr_space_p (acc,
 410                                  gdbarch_byte_order (gdbarch)
 411                                  == BFD_ENDIAN_BIG
 412                                  ? __BIG_ENDIAN
 413                                  : __LITTLE_ENDIAN);
 414
 415   ret = unw_init_remote_p (&cursor, as, this_frame);
 416
 417   if (ret < 0)
 418     {
 419       unw_destroy_addr_space_p (as);
 420       return 0;
 421     }
 422
 423   /* Check to see if we are in a signal frame.  */
 424   ret = unw_is_signal_frame_p (&cursor);
 425   unw_destroy_addr_space_p (as);
 426   if (ret > 0)
 427     return 1;
 428
 429   return 0;
 430 }
 431
 432 /* The following routine is for accessing special registers of the top frame.
 433    A special set of accessors must be given that work without frame info.
 434    This is used by ia64 to access the rse registers r32-r127.  While they
 435    are usually located at BOF, this is not always true and only the libunwind
 436    info can decipher where they actually are.  */
 437 int
 438 libunwind_get_reg_special (struct gdbarch *gdbarch, readable_regcache *regcache,
 439                            int regnum, void *buf)
 440 {
 441   unw_cursor_t cursor;
 442   unw_accessors_t *acc;
 443   unw_addr_space_t as;
 444   struct libunwind_descr *descr;
 445   int ret;
 446   unw_regnum_t uw_regnum;
 447   unw_word_t intval;
 448   unw_fpreg_t fpval;
 449   void *ptr;
 450
 451
 452   descr = libunwind_descr (gdbarch);
 453   acc = (unw_accessors_t *) descr->special_accessors;
 454   as =  unw_create_addr_space_p (acc,
 455                                  gdbarch_byte_order (gdbarch)
 456                                  == BFD_ENDIAN_BIG
 457                                  ? __BIG_ENDIAN
 458                                  : __LITTLE_ENDIAN);
 459
 460   ret = unw_init_remote_p (&cursor, as, regcache);
 461   if (ret < 0)
 462     {
 463       unw_destroy_addr_space_p (as);
 464       return -1;
 465     }
 466
 467   uw_regnum = descr->gdb2uw (regnum);
 468
 469   if (descr->is_fpreg (uw_regnum))
 470     {
 471       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 472       ptr = &fpval;
 473     }
 474   else
 475     {
 476       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 477       ptr = &intval;
 478     }
 479
 480   unw_destroy_addr_space_p (as);
 481
 482   if (ret < 0)
 483     return -1;
 484
 485   if (buf)
 486     memcpy (buf, ptr, register_size (gdbarch, regnum));
 487
 488   return 0;
 489 }
 490
 491 static int
 492 libunwind_load (void)
 493 {
 494   void *handle;
 495   char *so_error = NULL;
 496
 497   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 498   if (handle == NULL)
 499     {
 500       so_error = xstrdup (dlerror ());
 501 #ifdef LIBUNWIND_SO_7
 502       handle = dlopen (LIBUNWIND_SO_7, RTLD_NOW);
 503 #endif /* LIBUNWIND_SO_7 */
 504     }
 505   if (handle == NULL)
 506     {
 507       gdb_printf (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 508                   LIBUNWIND_SO, so_error);
 509 #ifdef LIBUNWIND_SO_7
 510       gdb_printf (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 511                   LIBUNWIND_SO_7, dlerror ());
 512 #endif /* LIBUNWIND_SO_7 */
 513     }
 514   xfree (so_error);
 515   if (handle == NULL)
 516     return 0;
 517
 518   /* Initialize pointers to the dynamic library functions we will use.  */
 519
 520   unw_get_reg_p = (unw_get_reg_p_ftype *) dlsym (handle, get_reg_name);
 521   if (unw_get_reg_p == NULL)
 522     return 0;
 523
 524   unw_get_fpreg_p = (unw_get_fpreg_p_ftype *) dlsym (handle, get_fpreg_name);
 525   if (unw_get_fpreg_p == NULL)
 526     return 0;
 527
 528   unw_get_saveloc_p
 529     = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name);
 530   if (unw_get_saveloc_p == NULL)
 531     return 0;
 532
 533   unw_is_signal_frame_p
 534     = (unw_is_signal_frame_p_ftype *) dlsym (handle, is_signal_frame_name);
 535   if (unw_is_signal_frame_p == NULL)
 536     return 0;
 537
 538   unw_step_p = (unw_step_p_ftype *) dlsym (handle, step_name);
 539   if (unw_step_p == NULL)
 540     return 0;
 541
 542   unw_init_remote_p
 543     = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name);
 544   if (unw_init_remote_p == NULL)
 545     return 0;
 546
 547   unw_create_addr_space_p
 548     = (unw_create_addr_space_p_ftype *) dlsym (handle, create_addr_space_name);
 549   if (unw_create_addr_space_p == NULL)
 550     return 0;
 551
 552   unw_destroy_addr_space_p
 553     = (unw_destroy_addr_space_p_ftype *) dlsym (handle,
 554                                                 destroy_addr_space_name);
 555   if (unw_destroy_addr_space_p == NULL)
 556     return 0;
 557
 558   unw_search_unwind_table_p
 559     = (unw_search_unwind_table_p_ftype *) dlsym (handle,
 560                                                  search_unwind_table_name);
 561   if (unw_search_unwind_table_p == NULL)
 562     return 0;
 563
 564   unw_find_dyn_list_p
 565     = (unw_find_dyn_list_p_ftype *) dlsym (handle, find_dyn_list_name);
 566   if (unw_find_dyn_list_p == NULL)
 567     return 0;
 568
 569   return 1;
 570 }
 571
 572 int
 573 libunwind_is_initialized (void)
 574 {
 575   return libunwind_initialized;
 576 }
 577
 578 void _initialize_libunwind_frame ();
 579 void
 580 _initialize_libunwind_frame ()
 581 {
 582   libunwind_initialized = libunwind_load ();
 583 }