gdb/libunwind-frame.c

   1 /* Frame unwinder for frames using the libunwind library.
   2
   3    Copyright 2003 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 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25
  26 #include "inferior.h"
  27 #include "frame.h"
  28 #include "frame-base.h"
  29 #include "frame-unwind.h"
  30 #include "gdbcore.h"
  31 #include "gdbtypes.h"
  32 #include "symtab.h"
  33 #include "objfiles.h"
  34 #include "regcache.h"
  35
  36 #include <dlfcn.h>
  37
  38 #include "gdb_assert.h"
  39 #include "gdb_string.h"
  40
  41 #include "libunwind-frame.h"
  42
  43 #include "complaints.h"
  44
  45 static int libunwind_initialized;
  46 static struct gdbarch_data *libunwind_descr_handle;
  47
  48 #ifndef LIBUNWIND_SO
  49 #define LIBUNWIND_SO "libunwind.so"
  50 #endif
  51
  52 /* Required function pointers from libunwind.  */
  53 static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  54 static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  55 static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
  56 static int (*unw_step_p) (unw_cursor_t *);
  57 static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  58 static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  59 static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
  60                                          unw_proc_info_t *, int, void *);
  61 static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  62                                           void *);
  63
  64
  65 struct libunwind_frame_cache
  66 {
  67   CORE_ADDR base;
  68   CORE_ADDR func_addr;
  69   unw_cursor_t cursor;
  70 };
  71
  72 /* We need to qualify the function names with a platform-specific prefix to match
  73    the names used by the libunwind library.  The UNW_OBJ macro is provided by the
  74    libunwind.h header file.  */
  75 #define STRINGIFY2(name)        #name
  76 #define STRINGIFY(name)         STRINGIFY2(name)
  77
  78 static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  79 static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  80 static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  81 static char *step_name = STRINGIFY(UNW_OBJ(step));
  82 static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  83 static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  84 static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
  85 static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
  86
  87 static struct libunwind_descr *
  88 libunwind_descr (struct gdbarch *gdbarch)
  89 {
  90   return gdbarch_data (gdbarch, libunwind_descr_handle);
  91 }
  92
  93 static void *
  94 libunwind_descr_init (struct gdbarch *gdbarch)
  95 {
  96   struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
  97                                                           struct libunwind_descr);
  98   return descr;
  99 }
 100
 101 void
 102 libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
 103 {
 104   struct libunwind_descr *arch_descr;
 105
 106   gdb_assert (gdbarch != NULL);
 107
 108   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
 109
 110   if (arch_descr == NULL)
 111     {
 112       /* First time here.  Must initialize data area.  */
 113       arch_descr = libunwind_descr_init (gdbarch);
 114       set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
 115     }
 116
 117   /* Copy new descriptor info into arch descriptor.  */
 118   arch_descr->gdb2uw = descr->gdb2uw;
 119   arch_descr->uw2gdb = descr->uw2gdb;
 120   arch_descr->is_fpreg = descr->is_fpreg;
 121   arch_descr->accessors = descr->accessors;
 122 }
 123
 124 static struct libunwind_frame_cache *
 125 libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
 126 {
 127   unw_accessors_t *acc;
 128   unw_addr_space_t as;
 129   unw_word_t fp;
 130   unw_regnum_t uw_sp_regnum;
 131   struct libunwind_frame_cache *cache;
 132   struct libunwind_descr *descr;
 133   int i, ret;
 134
 135   if (*this_cache)
 136     return *this_cache;
 137
 138   /* Allocate a new cache.  */
 139   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
 140
 141   cache->func_addr = frame_func_unwind (next_frame);
 142
 143   /* Get a libunwind cursor to the previous frame.  We do this by initializing
 144      a cursor.  Libunwind treats a new cursor as the top of stack and will get
 145      the current register set via the libunwind register accessor.  Now, we
 146      provide the platform-specific accessors and we set up the register accessor to use
 147      the frame register unwinding interfaces so that we properly get the registers for
 148      the current frame rather than the top.  We then use the  unw_step function to
 149      move the libunwind cursor back one frame.  We can later use this cursor to find previous
 150      registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
 151   descr = libunwind_descr (get_frame_arch (next_frame));
 152   acc = descr->accessors;
 153   as =  unw_create_addr_space_p (acc,
 154                                  TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 155                                  ? __BIG_ENDIAN
 156                                  : __LITTLE_ENDIAN);
 157
 158   unw_init_remote_p (&cache->cursor, as, next_frame);
 159   unw_step_p (&cache->cursor);
 160
 161   /* To get base address, get sp from previous frame.  */
 162   uw_sp_regnum = descr->gdb2uw (SP_REGNUM);
 163   ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
 164   if (ret < 0)
 165     error ("Can't get libunwind sp register.");
 166
 167   cache->base = (CORE_ADDR)fp;
 168
 169   *this_cache = cache;
 170   return cache;
 171 }
 172
 173 unw_word_t
 174 libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
 175 {
 176   return unw_find_dyn_list_p (as, di, arg);
 177 }
 178
 179 static const struct frame_unwind libunwind_frame_unwind =
 180 {
 181   NORMAL_FRAME,
 182   libunwind_frame_this_id,
 183   libunwind_frame_prev_register
 184 };
 185
 186 /* Verify if there is sufficient libunwind information for the frame to use
 187    libunwind frame unwinding.  */
 188 const struct frame_unwind *
 189 libunwind_frame_sniffer (struct frame_info *next_frame)
 190 {
 191   unw_cursor_t cursor;
 192   unw_accessors_t *acc;
 193   unw_addr_space_t as;
 194   struct libunwind_descr *descr;
 195   int i, ret;
 196
 197   /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
 198      up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
 199      If libunwind returns success for this operation, it means that it has found sufficient
 200      libunwind unwinding information to do so.  */
 201
 202   descr = libunwind_descr (get_frame_arch (next_frame));
 203   acc = descr->accessors;
 204   as =  unw_create_addr_space_p (acc,
 205                                  TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 206                                  ? __BIG_ENDIAN
 207                                  : __LITTLE_ENDIAN);
 208
 209   ret = unw_init_remote_p (&cursor, as, next_frame);
 210
 211   if (ret >= 0)
 212     ret = unw_step_p (&cursor);
 213
 214   if (ret < 0)
 215     return NULL;
 216
 217   return &libunwind_frame_unwind;
 218 }
 219
 220 void
 221 libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
 222                       struct frame_id *this_id)
 223 {
 224   struct libunwind_frame_cache *cache =
 225     libunwind_frame_cache (next_frame, this_cache);
 226
 227   (*this_id) = frame_id_build (cache->base, cache->func_addr);
 228 }
 229
 230 void
 231 libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 232                                int regnum, int *optimizedp,
 233                                enum lval_type *lvalp, CORE_ADDR *addrp,
 234                                int *realnump, void *valuep)
 235 {
 236   struct libunwind_frame_cache *cache =
 237     libunwind_frame_cache (next_frame, this_cache);
 238
 239   void *ptr;
 240   unw_cursor_t *c;
 241   unw_save_loc_t sl;
 242   int i, ret;
 243   unw_word_t intval;
 244   unw_fpreg_t fpval;
 245   unw_regnum_t uw_regnum;
 246   struct libunwind_descr *descr;
 247
 248   /* Convert from gdb register number to libunwind register number.  */
 249   descr = libunwind_descr (get_frame_arch (next_frame));
 250   uw_regnum = descr->gdb2uw (regnum);
 251
 252   gdb_assert (regnum >= 0);
 253
 254   if (!target_has_registers)
 255     error ("No registers.");
 256
 257   *optimizedp = 0;
 258   *addrp = 0;
 259   *lvalp = not_lval;
 260   *realnump = -1;
 261
 262   memset (valuep, 0, register_size (current_gdbarch, regnum));
 263
 264   if (uw_regnum < 0)
 265     return;
 266
 267   /* To get the previous register, we use the libunwind register APIs with
 268      the cursor we have already pushed back to the previous frame.  */
 269
 270   if (descr->is_fpreg (uw_regnum))
 271     {
 272       ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 273       ptr = &fpval;
 274     }
 275   else
 276     {
 277       ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 278       ptr = &intval;
 279     }
 280
 281   if (ret < 0)
 282     return;
 283
 284   memcpy (valuep, ptr, register_size (current_gdbarch, regnum));
 285
 286   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 287     return;
 288
 289   switch (sl.type)
 290     {
 291     case UNW_SLT_NONE:
 292       *optimizedp = 1;
 293       break;
 294
 295     case UNW_SLT_MEMORY:
 296       *lvalp = lval_memory;
 297       *addrp = sl.u.addr;
 298       break;
 299
 300     case UNW_SLT_REG:
 301       *lvalp = lval_register;
 302       *realnump = regnum;
 303       break;
 304     }
 305 }
 306
 307 CORE_ADDR
 308 libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
 309 {
 310   struct libunwind_frame_cache *cache =
 311     libunwind_frame_cache (next_frame, this_cache);
 312
 313   return cache->base;
 314 }
 315
 316 /* The following is a glue routine to call the libunwind unwind table
 317    search function to get unwind information for a specified ip address.  */
 318 int
 319 libunwind_search_unwind_table (void *as, long ip, void *di,
 320                                void *pi, int need_unwind_info, void *args)
 321 {
 322   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 323                                     di, pi, need_unwind_info, args);
 324 }
 325
 326 static int
 327 libunwind_load (void)
 328 {
 329   void *handle;
 330
 331   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 332   if (handle == NULL)
 333     return 0;
 334
 335   /* Initialize pointers to the dynamic library functions we will use.  */
 336
 337   unw_get_reg_p = dlsym (handle, get_reg_name);
 338   if (unw_get_reg_p == NULL)
 339     return 0;
 340
 341   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 342   if (unw_get_fpreg_p == NULL)
 343     return 0;
 344
 345   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 346   if (unw_get_saveloc_p == NULL)
 347     return 0;
 348
 349   unw_step_p = dlsym (handle, step_name);
 350   if (unw_step_p == NULL)
 351     return 0;
 352
 353   unw_init_remote_p = dlsym (handle, init_remote_name);
 354   if (unw_init_remote_p == NULL)
 355     return 0;
 356
 357   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 358   if (unw_create_addr_space_p == NULL)
 359     return 0;
 360
 361   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 362   if (unw_search_unwind_table_p == NULL)
 363     return 0;
 364
 365   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 366   if (unw_find_dyn_list_p == NULL)
 367     return 0;
 368
 369   return 1;
 370 }
 371
 372 int
 373 libunwind_is_initialized (void)
 374 {
 375   return libunwind_initialized;
 376 }
 377
 378 /* Provide a prototype to silence -Wmissing-prototypes.  */
 379 void _initialize_libunwind_frame (void);
 380
 381 void
 382 _initialize_libunwind_frame (void)
 383 {
 384   libunwind_descr_handle = register_gdbarch_data (libunwind_descr_init);
 385
 386   libunwind_initialized = libunwind_load ();
 387 }