gdb/ia64-libunwind-tdep.c

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