GDB (xrefs)
/tmp/gdb-7.10/gdb/ia64-libunwind-tdep.c
Go to the documentation of this file.
1 /* Frame unwinder for ia64 frames using the libunwind library.
2 
3  Copyright (C) 2003-2015 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 
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 
79 {
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 *
116 {
117  return gdbarch_data (gdbarch, libunwind_descr_handle);
118 }
119 
120 static void *
122 {
123  struct libunwind_descr *descr
124  = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);
125 
126  return descr;
127 }
128 
129 void
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);
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. */
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  {
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  {
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
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  {
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);
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 *
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 
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
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  {
420  return 0;
421  }
422 
423  /* Check to see if we are in a signal frame. */
424  ret = unw_is_signal_frame_p (&cursor);
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
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  {
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 
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
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 
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
565 {
566  return libunwind_initialized;
567 }
568 
569 /* Provide a prototype to silence -Wmissing-prototypes. */
570 void _initialize_libunwind_frame (void);
571 
572 void
574 {
575  libunwind_descr_handle
577 
578  libunwind_initialized = libunwind_load ();
579 }
#define target_has_registers
Definition: target.h:1710
void libunwind_frame_set_descr(struct gdbarch *gdbarch, struct libunwind_descr *descr)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
struct value * frame_unwind_got_bytes(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame-unwind.c:255
#define __LITTLE_ENDIAN
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void * libunwind_descr_init(struct gdbarch *gdbarch)
static int(* unw_get_reg_p)(unw_cursor_t *, unw_regnum_t, unw_word_t *)
void xfree(void *)
Definition: common-utils.c:97
void libunwind_frame_dealloc_cache(struct frame_info *self, void *this_cache)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
void libunwind_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
static unw_addr_space_t(* unw_create_addr_space_p)(unw_accessors_t *, int)
static char * search_unwind_table_name
#define _(String)
Definition: gdb_locale.h:40
static struct gdbarch_data * libunwind_descr_handle
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)
Definition: gdbarch.h:1615
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
#define LIBUNWIND_SO
static int(* unw_step_p)(unw_cursor_t *)
static char * get_reg_name
void _initialize_libunwind_frame(void)
static int(* unw_is_signal_frame_p)(unw_cursor_t *)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
int libunwind_is_initialized(void)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
static void(* unw_destroy_addr_space_p)(unw_addr_space_t)
static int(* unw_get_fpreg_p)(unw_cursor_t *, unw_regnum_t, unw_fpreg_t *)
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int(* unw_init_remote_p)(unw_cursor_t *, unw_addr_space_t, void *)
int regnum
Definition: aarch64-tdep.c:69
static int(* unw_search_unwind_table_p)(unw_addr_space_t, unw_word_t, unw_dyn_info_t *, unw_proc_info_t *, int, void *)
Definition: value.c:172
static int libunwind_load(void)
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
int libunwind_get_reg_special(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, void *buf)
int libunwind_sigtramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
int libunwind_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
struct ui_file * gdb_stderr
Definition: main.c:72
struct value * libunwind_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
#define STRINGIFY(name)
static unw_word_t(* unw_find_dyn_list_p)(unw_addr_space_t, unw_dyn_info_t *, void *)
void deprecated_set_gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data, void *pointer)
Definition: gdbarch.c:4831
static struct libunwind_frame_cache * libunwind_frame_cache(struct frame_info *this_frame, void **this_cache)
unw_word_t libunwind_find_dyn_list(unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
static struct libunwind_descr * libunwind_descr(struct gdbarch *gdbarch)
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
#define __BIG_ENDIAN
CORE_ADDR addr
Definition: frame.c:119
static int(* unw_get_saveloc_p)(unw_cursor_t *, unw_regnum_t, unw_save_loc_t *)
int libunwind_search_unwind_table(void *as, long ip, void *di, void *pi, int need_unwind_info, void *args)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
void error(const char *fmt,...)
Definition: errors.c:38
static int libunwind_initialized
#define LIBUNWIND_SO_7
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
Definition: gdbarch.c:4812
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535