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, void *, size_t,
  62                                           unw_word_t, unw_word_t, 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, void *table, size_t table_size,
 175                          unw_word_t segbase, unw_word_t gp, void *arg)
 176 {
 177   return unw_find_dyn_list_p (as, table, table_size, segbase, gp, arg);
 178 }
 179
 180 static const struct frame_unwind libunwind_frame_unwind =
 181 {
 182   NORMAL_FRAME,
 183   libunwind_frame_this_id,
 184   libunwind_frame_prev_register
 185 };
 186
 187 /* Verify if there is sufficient libunwind information for the frame to use
 188    libunwind frame unwinding.  */
 189 const struct frame_unwind *
 190 libunwind_frame_sniffer (struct frame_info *next_frame)
 191 {
 192   unw_cursor_t cursor;
 193   unw_accessors_t *acc;
 194   unw_addr_space_t as;
 195   struct libunwind_descr *descr;
 196   int i, ret;
 197
 198   /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
 199      up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
 200      If libunwind returns success for this operation, it means that it has found sufficient
 201      libunwind unwinding information to do so.  */
 202
 203   descr = libunwind_descr (get_frame_arch (next_frame));
 204   acc = descr->accessors;
 205   as =  unw_create_addr_space_p (acc,
 206                                  TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 207                                  ? __BIG_ENDIAN
 208                                  : __LITTLE_ENDIAN);
 209
 210   ret = unw_init_remote_p (&cursor, as, next_frame);
 211
 212   if (ret >= 0)
 213     ret = unw_step_p (&cursor);
 214
 215   if (ret < 0)
 216     return NULL;
 217
 218   return &libunwind_frame_unwind;
 219 }
 220
 221 void
 222 libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
 223                       struct frame_id *this_id)
 224 {
 225   struct libunwind_frame_cache *cache =
 226     libunwind_frame_cache (next_frame, this_cache);
 227
 228   (*this_id) = frame_id_build (cache->base, cache->func_addr);
 229 }
 230
 231 void
 232 libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 233                                int regnum, int *optimizedp,
 234                                enum lval_type *lvalp, CORE_ADDR *addrp,
 235                                int *realnump, void *valuep)
 236 {
 237   struct libunwind_frame_cache *cache =
 238     libunwind_frame_cache (next_frame, this_cache);
 239
 240   void *ptr;
 241   unw_cursor_t *c;
 242   unw_save_loc_t sl;
 243   int i, ret;
 244   unw_word_t intval;
 245   unw_fpreg_t fpval;
 246   unw_regnum_t uw_regnum;
 247   struct libunwind_descr *descr;
 248
 249   /* Convert from gdb register number to libunwind register number.  */
 250   descr = libunwind_descr (get_frame_arch (next_frame));
 251   uw_regnum = descr->gdb2uw (regnum);
 252
 253   gdb_assert (regnum >= 0);
 254
 255   if (!target_has_registers)
 256     error ("No registers.");
 257
 258   *optimizedp = 0;
 259   *addrp = 0;
 260   *lvalp = not_lval;
 261   *realnump = -1;
 262
 263   memset (valuep, 0, register_size (current_gdbarch, regnum));
 264
 265   if (uw_regnum < 0)
 266     return;
 267
 268   /* To get the previous register, we use the libunwind register APIs with
 269      the cursor we have already pushed back to the previous frame.  */
 270
 271   if (descr->is_fpreg (uw_regnum))
 272     {
 273       ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
 274       ptr = &fpval;
 275     }
 276   else
 277     {
 278       ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
 279       ptr = &intval;
 280     }
 281
 282   if (ret < 0)
 283     return;
 284
 285   memcpy (valuep, ptr, register_size (current_gdbarch, regnum));
 286
 287   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
 288     return;
 289
 290   switch (sl.type)
 291     {
 292     case UNW_SLT_NONE:
 293       *optimizedp = 1;
 294       break;
 295
 296     case UNW_SLT_MEMORY:
 297       *lvalp = lval_memory;
 298       *addrp = sl.u.addr;
 299       break;
 300
 301     case UNW_SLT_REG:
 302       *lvalp = lval_register;
 303       *realnump = regnum;
 304       break;
 305     }
 306 }
 307
 308 CORE_ADDR
 309 libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
 310 {
 311   struct libunwind_frame_cache *cache =
 312     libunwind_frame_cache (next_frame, this_cache);
 313
 314   return cache->base;
 315 }
 316
 317 /* The following is a glue routine to call the libunwind unwind table
 318    search function to get unwind information for a specified ip address.  */
 319 int
 320 libunwind_search_unwind_table (void *as, long ip, void *di,
 321                                void *pi, int need_unwind_info, void *args)
 322 {
 323   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
 324                                     di, pi, need_unwind_info, args);
 325 }
 326
 327 static int
 328 libunwind_load (void)
 329 {
 330   void *handle;
 331
 332   handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
 333   if (handle == NULL)
 334     return 0;
 335
 336   /* Initialize pointers to the dynamic library functions we will use.  */
 337
 338   unw_get_reg_p = dlsym (handle, get_reg_name);
 339   if (unw_get_reg_p == NULL)
 340     return 0;
 341
 342   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
 343   if (unw_get_fpreg_p == NULL)
 344     return 0;
 345
 346   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
 347   if (unw_get_saveloc_p == NULL)
 348     return 0;
 349
 350   unw_step_p = dlsym (handle, step_name);
 351   if (unw_step_p == NULL)
 352     return 0;
 353
 354   unw_init_remote_p = dlsym (handle, init_remote_name);
 355   if (unw_init_remote_p == NULL)
 356     return 0;
 357
 358   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
 359   if (unw_create_addr_space_p == NULL)
 360     return 0;
 361
 362   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
 363   if (unw_search_unwind_table_p == NULL)
 364     return 0;
 365
 366   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
 367   if (unw_find_dyn_list_p == NULL)
 368     return 0;
 369
 370   return 1;
 371 }
 372
 373 int
 374 libunwind_is_initialized (void)
 375 {
 376   return libunwind_initialized;
 377 }
 378
 379 /* Provide a prototype to silence -Wmissing-prototypes.  */
 380 void _initialize_libunwind_frame (void);
 381
 382 void
 383 _initialize_libunwind_frame (void)
 384 {
 385   libunwind_descr_handle = register_gdbarch_data (libunwind_descr_init);
 386
 387   libunwind_initialized = libunwind_load ();
 388 }