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
45static int libunwind_initialized;
46static 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.  */
53static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
54static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
55static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
56static int (*unw_step_p) (unw_cursor_t *);
57static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
58static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
59static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
60					 unw_proc_info_t *, int, void *);
61static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
62					  void *);
63
64
65struct 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
78static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
79static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
80static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
81static char *step_name = STRINGIFY(UNW_OBJ(step));
82static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
83static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
84static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
85static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
86
87static struct libunwind_descr *
88libunwind_descr (struct gdbarch *gdbarch)
89{
90  return gdbarch_data (gdbarch, libunwind_descr_handle);
91}
92
93static void *
94libunwind_descr_init (struct gdbarch *gdbarch)
95{
96  struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
97							  struct libunwind_descr);
98  return descr;
99}
100
101void
102libunwind_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
124static struct libunwind_frame_cache *
125libunwind_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
173unw_word_t
174libunwind_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
179static 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.  */
188const struct frame_unwind *
189libunwind_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
220void
221libunwind_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
230void
231libunwind_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
307CORE_ADDR
308libunwind_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.  */
318int
319libunwind_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
326static int
327libunwind_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
372int
373libunwind_is_initialized (void)
374{
375  return libunwind_initialized;
376}
377
378/* Provide a prototype to silence -Wmissing-prototypes.  */
379void _initialize_libunwind_frame (void);
380
381void
382_initialize_libunwind_frame (void)
383{
384  libunwind_descr_handle = register_gdbarch_data (libunwind_descr_init);
385
386  libunwind_initialized = libunwind_load ();
387}
388