gdb/libunwind-frame.c

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