1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
5 Written by Jeff Johnston, contributed by Red Hat Inc.
7 This file is part of GDB.
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.
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.
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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "frame-base.h"
29 #include "frame-unwind.h"
38 #include "gdb_assert.h"
39 #include "gdb_string.h"
41 #include "libunwind-frame.h"
43 #include "complaints.h"
45 static int libunwind_initialized
;
46 static struct gdbarch_data
*libunwind_descr_handle
;
48 /* Required function pointers from libunwind. */
49 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
50 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
51 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
, unw_save_loc_t
*);
52 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
53 static int (*unw_step_p
) (unw_cursor_t
*);
54 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
55 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
56 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
57 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
, unw_dyn_info_t
*,
58 unw_proc_info_t
*, int, void *);
59 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
63 struct libunwind_frame_cache
70 /* We need to qualify the function names with a platform-specific prefix to match
71 the names used by the libunwind library. The UNW_OBJ macro is provided by the
72 libunwind.h header file. */
73 #define STRINGIFY2(name) #name
74 #define STRINGIFY(name) STRINGIFY2(name)
77 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
78 only library, not a runtime one. */
79 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
82 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
83 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
84 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
85 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
86 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
87 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
88 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
89 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
90 static char *search_unwind_table_name
= STRINGIFY(UNW_OBJ(search_unwind_table
));
91 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
93 static struct libunwind_descr
*
94 libunwind_descr (struct gdbarch
*gdbarch
)
96 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
100 libunwind_descr_init (struct gdbarch
*gdbarch
)
102 struct libunwind_descr
*descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
,
103 struct libunwind_descr
);
108 libunwind_frame_set_descr (struct gdbarch
*gdbarch
, struct libunwind_descr
*descr
)
110 struct libunwind_descr
*arch_descr
;
112 gdb_assert (gdbarch
!= NULL
);
114 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
116 if (arch_descr
== NULL
)
118 /* First time here. Must initialize data area. */
119 arch_descr
= libunwind_descr_init (gdbarch
);
120 deprecated_set_gdbarch_data (gdbarch
, libunwind_descr_handle
, arch_descr
);
123 /* Copy new descriptor info into arch descriptor. */
124 arch_descr
->gdb2uw
= descr
->gdb2uw
;
125 arch_descr
->uw2gdb
= descr
->uw2gdb
;
126 arch_descr
->is_fpreg
= descr
->is_fpreg
;
127 arch_descr
->accessors
= descr
->accessors
;
128 arch_descr
->special_accessors
= descr
->special_accessors
;
131 static struct libunwind_frame_cache
*
132 libunwind_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
134 unw_accessors_t
*acc
;
137 unw_regnum_t uw_sp_regnum
;
138 struct libunwind_frame_cache
*cache
;
139 struct libunwind_descr
*descr
;
145 /* Allocate a new cache. */
146 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
148 /* We can assume we are unwinding a normal frame. Even if this is
149 for a signal trampoline, ia64 signal "trampolines" use a normal
150 subroutine call to start the signal handler. */
151 cache
->func_addr
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
152 if (cache
->func_addr
== 0
153 && frame_relative_level (next_frame
) > 0
154 && get_frame_type (next_frame
) != SIGTRAMP_FRAME
)
157 /* Get a libunwind cursor to the previous frame. We do this by initializing
158 a cursor. Libunwind treats a new cursor as the top of stack and will get
159 the current register set via the libunwind register accessor. Now, we
160 provide the platform-specific accessors and we set up the register accessor to use
161 the frame register unwinding interfaces so that we properly get the registers for
162 the current frame rather than the top. We then use the unw_step function to
163 move the libunwind cursor back one frame. We can later use this cursor to find previous
164 registers via the unw_get_reg interface which will invoke libunwind's special logic. */
165 descr
= libunwind_descr (get_frame_arch (next_frame
));
166 acc
= descr
->accessors
;
167 as
= unw_create_addr_space_p (acc
,
168 gdbarch_byte_order (current_gdbarch
)
173 unw_init_remote_p (&cache
->cursor
, as
, next_frame
);
174 if (unw_step_p (&cache
->cursor
) < 0)
176 unw_destroy_addr_space_p (as
);
180 /* To get base address, get sp from previous frame. */
181 uw_sp_regnum
= descr
->gdb2uw (SP_REGNUM
);
182 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
185 unw_destroy_addr_space_p (as
);
186 error (_("Can't get libunwind sp register."));
189 cache
->base
= (CORE_ADDR
)fp
;
196 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
198 return unw_find_dyn_list_p (as
, di
, arg
);
201 static const struct frame_unwind libunwind_frame_unwind
=
204 libunwind_frame_this_id
,
205 libunwind_frame_prev_register
208 /* Verify if there is sufficient libunwind information for the frame to use
209 libunwind frame unwinding. */
210 const struct frame_unwind
*
211 libunwind_frame_sniffer (struct frame_info
*next_frame
)
214 unw_accessors_t
*acc
;
216 struct libunwind_descr
*descr
;
219 /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
220 up. We use this same method when setting up the frame cache (see libunwind_frame_cache()).
221 If libunwind returns success for this operation, it means that it has found sufficient
222 libunwind unwinding information to do so. */
224 descr
= libunwind_descr (get_frame_arch (next_frame
));
225 acc
= descr
->accessors
;
226 as
= unw_create_addr_space_p (acc
,
227 gdbarch_byte_order (current_gdbarch
)
232 ret
= unw_init_remote_p (&cursor
, as
, next_frame
);
236 unw_destroy_addr_space_p (as
);
241 /* Check to see if we have libunwind info by checking if we are in a
242 signal frame. If it doesn't return an error, we have libunwind info
243 and can use libunwind. */
244 ret
= unw_is_signal_frame_p (&cursor
);
245 unw_destroy_addr_space_p (as
);
250 return &libunwind_frame_unwind
;
254 libunwind_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
255 struct frame_id
*this_id
)
257 struct libunwind_frame_cache
*cache
=
258 libunwind_frame_cache (next_frame
, this_cache
);
261 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
263 (*this_id
) = null_frame_id
;
267 libunwind_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
268 int regnum
, int *optimizedp
,
269 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
270 int *realnump
, gdb_byte
*valuep
)
272 struct libunwind_frame_cache
*cache
=
273 libunwind_frame_cache (next_frame
, this_cache
);
281 unw_regnum_t uw_regnum
;
282 struct libunwind_descr
*descr
;
287 /* Convert from gdb register number to libunwind register number. */
288 descr
= libunwind_descr (get_frame_arch (next_frame
));
289 uw_regnum
= descr
->gdb2uw (regnum
);
291 gdb_assert (regnum
>= 0);
293 if (!target_has_registers
)
294 error (_("No registers."));
302 memset (valuep
, 0, register_size (current_gdbarch
, regnum
));
307 /* To get the previous register, we use the libunwind register APIs with
308 the cursor we have already pushed back to the previous frame. */
310 if (descr
->is_fpreg (uw_regnum
))
312 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
317 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
325 memcpy (valuep
, ptr
, register_size (current_gdbarch
, regnum
));
327 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
337 *lvalp
= lval_memory
;
342 *lvalp
= lval_register
;
349 libunwind_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
351 struct libunwind_frame_cache
*cache
=
352 libunwind_frame_cache (next_frame
, this_cache
);
355 return (CORE_ADDR
)NULL
;
359 /* The following is a glue routine to call the libunwind unwind table
360 search function to get unwind information for a specified ip address. */
362 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
363 void *pi
, int need_unwind_info
, void *args
)
365 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
366 di
, pi
, need_unwind_info
, args
);
369 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
370 const struct frame_unwind
*
371 libunwind_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
374 unw_accessors_t
*acc
;
376 struct libunwind_descr
*descr
;
379 /* To test for libunwind unwind support, initialize a cursor to the
380 current frame and try to back up. We use this same method when
381 setting up the frame cache (see libunwind_frame_cache()). If
382 libunwind returns success for this operation, it means that it
383 has found sufficient libunwind unwinding information to do
386 descr
= libunwind_descr (get_frame_arch (next_frame
));
387 acc
= descr
->accessors
;
388 as
= unw_create_addr_space_p (acc
,
389 gdbarch_byte_order (current_gdbarch
)
394 ret
= unw_init_remote_p (&cursor
, as
, next_frame
);
398 unw_destroy_addr_space_p (as
);
402 /* Check to see if we are in a signal frame. */
403 ret
= unw_is_signal_frame_p (&cursor
);
404 unw_destroy_addr_space_p (as
);
406 return &libunwind_frame_unwind
;
411 /* The following routine is for accessing special registers of the top frame.
412 A special set of accessors must be given that work without frame info.
413 This is used by ia64 to access the rse registers r32-r127. While they
414 are usually located at BOF, this is not always true and only the libunwind
415 info can decipher where they actually are. */
417 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
418 int regnum
, void *buf
)
421 unw_accessors_t
*acc
;
423 struct libunwind_descr
*descr
;
425 unw_regnum_t uw_regnum
;
431 descr
= libunwind_descr (gdbarch
);
432 acc
= descr
->special_accessors
;
433 as
= unw_create_addr_space_p (acc
,
434 gdbarch_byte_order (current_gdbarch
)
439 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
442 unw_destroy_addr_space_p (as
);
446 uw_regnum
= descr
->gdb2uw (regnum
);
448 if (descr
->is_fpreg (uw_regnum
))
450 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
455 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
459 unw_destroy_addr_space_p (as
);
465 memcpy (buf
, ptr
, register_size (current_gdbarch
, regnum
));
471 libunwind_load (void)
475 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
479 /* Initialize pointers to the dynamic library functions we will use. */
481 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
482 if (unw_get_reg_p
== NULL
)
485 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
486 if (unw_get_fpreg_p
== NULL
)
489 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
490 if (unw_get_saveloc_p
== NULL
)
493 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
494 if (unw_is_signal_frame_p
== NULL
)
497 unw_step_p
= dlsym (handle
, step_name
);
498 if (unw_step_p
== NULL
)
501 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
502 if (unw_init_remote_p
== NULL
)
505 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
506 if (unw_create_addr_space_p
== NULL
)
509 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
510 if (unw_destroy_addr_space_p
== NULL
)
513 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
514 if (unw_search_unwind_table_p
== NULL
)
517 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
518 if (unw_find_dyn_list_p
== NULL
)
525 libunwind_is_initialized (void)
527 return libunwind_initialized
;
530 /* Provide a prototype to silence -Wmissing-prototypes. */
531 void _initialize_libunwind_frame (void);
534 _initialize_libunwind_frame (void)
536 libunwind_descr_handle
= gdbarch_data_register_post_init (libunwind_descr_init
);
538 libunwind_initialized
= libunwind_load ();