gdb/ia64-libunwind-tdep.c

   1 /* Frame unwinder for ia64 frames using the libunwind library.
   2
   3    Copyright (C) 2003-2014 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 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  63 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  64 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t,
  65                                  unw_save_loc_t *);
  66 static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  67 static int (*unw_step_p) (unw_cursor_t *);
  68 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  69 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  70 static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  71 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t,
  72                                          unw_dyn_info_t *,
  73                                          unw_proc_info_t *, int, void *);
  74 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  75                                           void *);
  76
  77
  78 struct libunwind_frame_cache
  79 {
  80   CORE_ADDR base;
  81   CORE_ADDR func_addr;
  82   unw_cursor_t cursor;
  83   unw_addr_space_t as;
  84 };
  85
  86 /* We need to qualify the function names with a platform-specific prefix
  87    to match the names used by the libunwind library.  The UNW_OBJ macro is
  88    provided by the libunwind.h header file.  */
  89 #define STRINGIFY2(name)        #name
  90 #define STRINGIFY(name)         STRINGIFY2(name)
  91
  92 #ifndef LIBUNWIND_SO
  93 /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  94    only library, not a runtime one.  */
  95 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
  96
  97 /* Provide also compatibility with older .so.  The two APIs are compatible, .8
  98    is only extended a bit, GDB does not use the extended API at all.  */
  99 #define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
 100 #endif
 101
 102 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
 103 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
 104 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
 105 static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
 106 static char *step_name = STRINGIFY(UNW_OBJ(step));
 107 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
 108 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
 109 static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
 110 static char *search_unwind_table_name
 111   = STRINGIFY(UNW_OBJ(search_unwind_table));
 112 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
 113
 114 static struct libunwind_descr *
 115 libunwind_descr (struct gdbarch *gdbarch)
 116 {
 117   return gdbarch_data (gdbarch, libunwind_descr_handle);
 118 }
 119
 120 static void *
 121 libunwind_descr_init (struct gdbarch *gdbarch)
 122 {
 123   struct libunwind_descr *descr
 124     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
 125
 126   return descr;
 127 }
 128
 129 void
 130 libunwind_frame_set_descr (struct gdbarch *gdbarch,
 131                            struct libunwind_descr *descr)
 132 {
 133   struct libunwind_descr *arch_descr;
 134
 135   gdb_assert (gdbarch != NULL);
 136
 137   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 138
 139   if (arch_descr == NULL)
 140     {
 141       /* First time here.  Must initialize data area.  */
 142       arch_descr = libunwind_descr_init (gdbarch);
 143       deprecated_set_gdbarch_data (gdbarch,
 144                                    libunwind_descr_handle, arch_descr);
 145     }
 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 (struct frame_info *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 i, ret;
 166
 167   if (*this_cache)
 168     return *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 abandonning 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 = 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 (struct frame_info *self, void *this_cache)
 232 {
 233   struct libunwind_frame_cache *cache = this_cache;
 234
 235   if (cache->as)
 236     unw_destroy_addr_space_p (cache->as);
 237 }
 238
 239 unw_word_t
 240 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 241 {
 242   return unw_find_dyn_list_p (as, di, arg);
 243 }
 244
 245 /* Verify if there is sufficient libunwind information for the frame to use
 246    libunwind frame unwinding.  */
 247 int
 248 libunwind_frame_sniffer (const struct frame_unwind *self,
 249                          struct frame_info *this_frame, void **this_cache)
 250 {
 251   unw_cursor_t cursor;
 252   unw_accessors_t *acc;
 253   unw_addr_space_t as;
 254   struct libunwind_descr *descr;
 255   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 256   int i, ret;
 257
 258   /* To test for libunwind unwind support, initialize a cursor to
 259      the current frame and try to back up.  We use this same method
 260      when setting up the frame cache (see libunwind_frame_cache()).
 261      If libunwind returns success for this operation, it means that
 262      it has found sufficient libunwind unwinding information to do so.  */
 263
 264   descr = libunwind_descr (gdbarch);
 265   acc = descr->accessors;
 266   as =  unw_create_addr_space_p (acc,
 267                                  gdbarch_byte_order (gdbarch)
 268                                  == BFD_ENDIAN_BIG
 269                                  ? __BIG_ENDIAN
 270                                  : __LITTLE_ENDIAN);
 271
 272   ret = unw_init_remote_p (&cursor, as, this_frame);
 273
 274   if (ret < 0)
 275     {
 276       unw_destroy_addr_space_p (as);
 277       return 0;
 278     }
 279
 280
 281   /* Check to see if we have libunwind info by checking if we are in a
 282      signal frame.  If it doesn't return an error, we have libunwind info
 283      and can use libunwind.  */
 284   ret = unw_is_signal_frame_p (&cursor);
 285   unw_destroy_addr_space_p (as);
 286
 287   if (ret < 0)
 288     return 0;
 289
 290   return 1;
 291 }
 292
 293 void
 294 libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 295                          struct frame_id *this_id)
 296 {
 297   struct libunwind_frame_cache *cache =
 298     libunwind_frame_cache (this_frame, this_cache);
 299
 300   if (cache != NULL)
 301     (*this_id) = frame_id_build (cache->base, cache->func_addr);
 302 }
 303
 304 struct value *
 305 libunwind_frame_prev_register (struct frame_info *this_frame,
 306                                void **this_cache, int regnum)
 307 {
 308   struct libunwind_frame_cache *cache =
 309     libunwind_frame_cache (this_frame, this_cache);
 310   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 311
 312   void *ptr;
 313   unw_cursor_t *c;
 314   unw_save_loc_t sl;
 315   int i, ret;
 316   unw_word_t intval;
 317   unw_fpreg_t fpval;
 318   unw_regnum_t uw_regnum;
 319   struct libunwind_descr *descr;
 320   struct value *val = NULL;
 321
 322   if (cache == NULL)
 323     return frame_unwind_got_constant (this_frame, regnum, 0);
 324
 325   /* Convert from gdb register number to libunwind register number.  */
 326   descr = libunwind_descr (get_frame_arch (this_frame));
 327   uw_regnum = descr->gdb2uw (regnum);
 328
 329   gdb_assert (regnum >= 0);
 330
 331   if (!target_has_registers)
 332     error (_("No registers."));
 333
 334   if (uw_regnum < 0)
 335     return frame_unwind_got_constant (this_frame, regnum, 0);
 336
 337   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 338     return frame_unwind_got_constant (this_frame, regnum, 0);
 339
 340   switch (sl.type)
 341     {
 342     case UNW_SLT_MEMORY:
 343       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
 344       break;
 345
 346     case UNW_SLT_REG:
 347       val = frame_unwind_got_register (this_frame, regnum,
 348                                        descr->uw2gdb (sl.u.regnum));
 349       break;
 350     case UNW_SLT_NONE:
 351       {
 352         /* The register is not stored at a specific memory address nor
 353            inside another register.  So use libunwind to fetch the register
 354            value for us, and create a constant value with the result.  */
 355         if (descr->is_fpreg (uw_regnum))
 356           {
 357             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 358             if (ret < 0)
 359               return frame_unwind_got_constant (this_frame, regnum, 0);
 360             val = frame_unwind_got_bytes (this_frame, regnum,
 361                                           (gdb_byte *) &fpval);
 362           }
 363         else
 364           {
 365             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 366             if (ret < 0)
 367               return frame_unwind_got_constant (this_frame, regnum, 0);
 368             val = frame_unwind_got_constant (this_frame, regnum, intval);
 369           }
 370         break;
 371       }
 372     }
 373
 374   return val;
 375 }
 376
 377 /* The following is a glue routine to call the libunwind unwind table
 378    search function to get unwind information for a specified ip address.  */
 379 int
 380 libunwind_search_unwind_table (void *as, long ip, void *di,
 381                                void *pi, int need_unwind_info, void *args)
 382 {
 383   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 384                                     di, pi, need_unwind_info, 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                                   struct frame_info *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 i, 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 = 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, struct 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 = 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       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
 508                           LIBUNWIND_SO, so_error);
 509 #ifdef LIBUNWIND_SO_7
 510       fprintf_unfiltered (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 = dlsym (handle, get_reg_name);
 521   if (unw_get_reg_p == NULL)
 522     return 0;
 523
 524   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 525   if (unw_get_fpreg_p == NULL)
 526     return 0;
 527
 528   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 529   if (unw_get_saveloc_p == NULL)
 530     return 0;
 531
 532   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
 533   if (unw_is_signal_frame_p == NULL)
 534     return 0;
 535
 536   unw_step_p = dlsym (handle, step_name);
 537   if (unw_step_p == NULL)
 538     return 0;
 539
 540   unw_init_remote_p = dlsym (handle, init_remote_name);
 541   if (unw_init_remote_p == NULL)
 542     return 0;
 543
 544   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 545   if (unw_create_addr_space_p == NULL)
 546     return 0;
 547
 548   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
 549   if (unw_destroy_addr_space_p == NULL)
 550     return 0;
 551
 552   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 553   if (unw_search_unwind_table_p == NULL)
 554     return 0;
 555
 556   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 557   if (unw_find_dyn_list_p == NULL)
 558     return 0;
 559
 560   return 1;
 561 }
 562
 563 int
 564 libunwind_is_initialized (void)
 565 {
 566   return libunwind_initialized;
 567 }
 568
 569 /* Provide a prototype to silence -Wmissing-prototypes.  */
 570 void _initialize_libunwind_frame (void);
 571
 572 void
 573 _initialize_libunwind_frame (void)
 574 {
 575   libunwind_descr_handle
 576     = gdbarch_data_register_post_init (libunwind_descr_init);
 577
 578   libunwind_initialized = libunwind_load ();
 579 }