gdb/ia64-libunwind-tdep.c

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