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 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 i, 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 abandonning 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 i, 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   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 328
 329   void *ptr;
 330   unw_cursor_t *c;
 331   unw_save_loc_t sl;
 332   int i, ret;
 333   unw_word_t intval;
 334   unw_fpreg_t fpval;
 335   unw_regnum_t uw_regnum;
 336   struct libunwind_descr *descr;
 337   struct value *val = NULL;
 338
 339   if (cache == NULL)
 340     return frame_unwind_got_constant (this_frame, regnum, 0);
 341
 342   /* Convert from gdb register number to libunwind register number.  */
 343   descr = libunwind_descr (get_frame_arch (this_frame));
 344   uw_regnum = descr->gdb2uw (regnum);
 345
 346   gdb_assert (regnum >= 0);
 347
 348   if (!target_has_registers)
 349     error (_("No registers."));
 350
 351   if (uw_regnum < 0)
 352     return frame_unwind_got_constant (this_frame, regnum, 0);
 353
 354   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 355     return frame_unwind_got_constant (this_frame, regnum, 0);
 356
 357   switch (sl.type)
 358     {
 359     case UNW_SLT_MEMORY:
 360       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 361       break;
 362
 363     case UNW_SLT_REG:
 364       val = frame_unwind_got_register (this_frame, regnum,
 365                                        descr->uw2gdb (sl.u.regnum));
 366       break;
 367     case UNW_SLT_NONE:
 368       {
 369         /* The register is not stored at a specific memory address nor
 370            inside another register.  So use libunwind to fetch the register
 371            value for us, and create a constant value with the result.  */
 372         if (descr->is_fpreg (uw_regnum))
 373           {
 374             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 375             if (ret < 0)
 376               return frame_unwind_got_constant (this_frame, regnum, 0);
 377             val = frame_unwind_got_bytes (this_frame, regnum,
 378                                           (gdb_byte *) &fpval);
 379           }
 380         else
 381           {
 382             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 383             if (ret < 0)
 384               return frame_unwind_got_constant (this_frame, regnum, 0);
 385             val = frame_unwind_got_constant (this_frame, regnum, intval);
 386           }
 387         break;
 388       }
 389     }
 390
 391   return val;
 392 }
 393
 394 /* The following is a glue routine to call the libunwind unwind table
 395    search function to get unwind information for a specified ip address.  */
 396 int
 397 libunwind_search_unwind_table (void *as, long ip, void *di,
 398                                void *pi, int need_unwind_info, void *args)
 399 {
 400   return unw_search_unwind_table_p (*(unw_addr_space_t *) as, (unw_word_t) ip,
 401                                     (unw_dyn_info_t *) di,
 402                                     (unw_proc_info_t *) pi, need_unwind_info,
 403                                     args);
 404 }
 405
 406 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
 407 int
 408 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
 409                                   struct frame_info *this_frame,
 410                                   void **this_cache)
 411 {
 412   unw_cursor_t cursor;
 413   unw_accessors_t *acc;
 414   unw_addr_space_t as;
 415   struct libunwind_descr *descr;
 416   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 417   int i, ret;
 418
 419   /* To test for libunwind unwind support, initialize a cursor to the
 420      current frame and try to back up.  We use this same method when
 421      setting up the frame cache (see libunwind_frame_cache()).  If
 422      libunwind returns success for this operation, it means that it
 423      has found sufficient libunwind unwinding information to do
 424      so.  */
 425
 426   descr = libunwind_descr (gdbarch);
 427   acc = (unw_accessors_t *) descr->accessors;
 428   as =  unw_create_addr_space_p (acc,
 429                                  gdbarch_byte_order (gdbarch)
 430                                  == BFD_ENDIAN_BIG
 431                                  ? __BIG_ENDIAN
 432                                  : __LITTLE_ENDIAN);
 433
 434   ret = unw_init_remote_p (&cursor, as, this_frame);
 435
 436   if (ret < 0)
 437     {
 438       unw_destroy_addr_space_p (as);
 439       return 0;
 440     }
 441
 442   /* Check to see if we are in a signal frame.  */
 443   ret = unw_is_signal_frame_p (&cursor);
 444   unw_destroy_addr_space_p (as);
 445   if (ret > 0)
 446     return 1;
 447
 448   return 0;
 449 }
 450
 451 /* The following routine is for accessing special registers of the top frame.
 452    A special set of accessors must be given that work without frame info.
 453    This is used by ia64 to access the rse registers r32-r127.  While they
 454    are usually located at BOF, this is not always true and only the libunwind
 455    info can decipher where they actually are.  */
 456 int
 457 libunwind_get_reg_special (struct gdbarch *gdbarch, readable_regcache *regcache,
 458                            int regnum, void *buf)
 459 {
 460   unw_cursor_t cursor;
 461   unw_accessors_t *acc;
 462   unw_addr_space_t as;
 463   struct libunwind_descr *descr;
 464   int ret;
 465   unw_regnum_t uw_regnum;
 466   unw_word_t intval;
 467   unw_fpreg_t fpval;
 468   void *ptr;
 469
 470
 471   descr = libunwind_descr (gdbarch);
 472   acc = (unw_accessors_t *) descr->special_accessors;
 473   as =  unw_create_addr_space_p (acc,
 474                                  gdbarch_byte_order (gdbarch)
 475                                  == BFD_ENDIAN_BIG
 476                                  ? __BIG_ENDIAN
 477                                  : __LITTLE_ENDIAN);
 478
 479   ret = unw_init_remote_p (&cursor, as, regcache);
 480   if (ret < 0)
 481     {
 482       unw_destroy_addr_space_p (as);
 483       return -1;
 484     }
 485
 486   uw_regnum = descr->gdb2uw (regnum);
 487
 488   if (descr->is_fpreg (uw_regnum))
 489     {
 490       ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
 491       ptr = &fpval;
 492     }
 493   else
 494     {
 495       ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
 496       ptr = &intval;
 497     }
 498
 499   unw_destroy_addr_space_p (as);
 500
 501   if (ret < 0)
 502     return -1;
 503
 504   if (buf)
 505     memcpy (buf, ptr, register_size (gdbarch, regnum));
 506
 507   return 0;
 508 }
 509
 510 static int
 511 libunwind_load (void)
 512 {
 513   void *handle;
 514   char *so_error = NULL;
 515
 516   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 517   if (handle == NULL)
 518     {
 519       so_error = xstrdup (dlerror ());
 520 #ifdef LIBUNWIND_SO_7
 521       handle = dlopen (LIBUNWIND_SO_7, RTLD_NOW);
 522 #endif /* LIBUNWIND_SO_7 */
 523     }
 524   if (handle == NULL)
 525     {
 526       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 527                           LIBUNWIND_SO, so_error);
 528 #ifdef LIBUNWIND_SO_7
 529       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 530                           LIBUNWIND_SO_7, dlerror ());
 531 #endif /* LIBUNWIND_SO_7 */
 532     }
 533   xfree (so_error);
 534   if (handle == NULL)
 535     return 0;
 536
 537   /* Initialize pointers to the dynamic library functions we will use.  */
 538
 539   unw_get_reg_p = (unw_get_reg_p_ftype *) dlsym (handle, get_reg_name);
 540   if (unw_get_reg_p == NULL)
 541     return 0;
 542
 543   unw_get_fpreg_p = (unw_get_fpreg_p_ftype *) dlsym (handle, get_fpreg_name);
 544   if (unw_get_fpreg_p == NULL)
 545     return 0;
 546
 547   unw_get_saveloc_p
 548     = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name);
 549   if (unw_get_saveloc_p == NULL)
 550     return 0;
 551
 552   unw_is_signal_frame_p
 553     = (unw_is_signal_frame_p_ftype *) dlsym (handle, is_signal_frame_name);
 554   if (unw_is_signal_frame_p == NULL)
 555     return 0;
 556
 557   unw_step_p = (unw_step_p_ftype *) dlsym (handle, step_name);
 558   if (unw_step_p == NULL)
 559     return 0;
 560
 561   unw_init_remote_p
 562     = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name);
 563   if (unw_init_remote_p == NULL)
 564     return 0;
 565
 566   unw_create_addr_space_p
 567     = (unw_create_addr_space_p_ftype *) dlsym (handle, create_addr_space_name);
 568   if (unw_create_addr_space_p == NULL)
 569     return 0;
 570
 571   unw_destroy_addr_space_p
 572     = (unw_destroy_addr_space_p_ftype *) dlsym (handle,
 573                                                 destroy_addr_space_name);
 574   if (unw_destroy_addr_space_p == NULL)
 575     return 0;
 576
 577   unw_search_unwind_table_p
 578     = (unw_search_unwind_table_p_ftype *) dlsym (handle,
 579                                                  search_unwind_table_name);
 580   if (unw_search_unwind_table_p == NULL)
 581     return 0;
 582
 583   unw_find_dyn_list_p
 584     = (unw_find_dyn_list_p_ftype *) dlsym (handle, find_dyn_list_name);
 585   if (unw_find_dyn_list_p == NULL)
 586     return 0;
 587
 588   return 1;
 589 }
 590
 591 int
 592 libunwind_is_initialized (void)
 593 {
 594   return libunwind_initialized;
 595 }
 596
 597 void
 598 _initialize_libunwind_frame (void)
 599 {
 600   libunwind_descr_handle
 601     = gdbarch_data_register_post_init (libunwind_descr_init);
 602
 603   libunwind_initialized = libunwind_load ();
 604 }