1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "frame-base.h"
27 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "libunwind-frame.h"
41 #include "complaints.h"
43 static int libunwind_initialized
;
44 static struct gdbarch_data
*libunwind_descr_handle
;
46 /* Required function pointers from libunwind. */
47 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
48 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
49 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
, unw_save_loc_t
*);
50 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
51 static int (*unw_step_p
) (unw_cursor_t
*);
52 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
53 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
54 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
55 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
, unw_dyn_info_t
*,
56 unw_proc_info_t
*, int, void *);
57 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
61 struct libunwind_frame_cache
69 /* We need to qualify the function names with a platform-specific prefix to match
70 the names used by the libunwind library. The UNW_OBJ macro is provided by the
71 libunwind.h header file. */
72 #define STRINGIFY2(name) #name
73 #define STRINGIFY(name) STRINGIFY2(name)
76 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
77 only library, not a runtime one. */
78 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
81 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
82 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
83 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
84 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
85 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
86 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
87 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
88 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
89 static char *search_unwind_table_name
= STRINGIFY(UNW_OBJ(search_unwind_table
));
90 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
92 static struct libunwind_descr
*
93 libunwind_descr (struct gdbarch
*gdbarch
)
95 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
99 libunwind_descr_init (struct gdbarch
*gdbarch
)
101 struct libunwind_descr
*descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
,
102 struct libunwind_descr
);
107 libunwind_frame_set_descr (struct gdbarch
*gdbarch
, struct libunwind_descr
*descr
)
109 struct libunwind_descr
*arch_descr
;
111 gdb_assert (gdbarch
!= NULL
);
113 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
115 if (arch_descr
== NULL
)
117 /* First time here. Must initialize data area. */
118 arch_descr
= libunwind_descr_init (gdbarch
);
119 deprecated_set_gdbarch_data (gdbarch
, libunwind_descr_handle
, arch_descr
);
122 /* Copy new descriptor info into arch descriptor. */
123 arch_descr
->gdb2uw
= descr
->gdb2uw
;
124 arch_descr
->uw2gdb
= descr
->uw2gdb
;
125 arch_descr
->is_fpreg
= descr
->is_fpreg
;
126 arch_descr
->accessors
= descr
->accessors
;
127 arch_descr
->special_accessors
= descr
->special_accessors
;
130 static struct libunwind_frame_cache
*
131 libunwind_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
133 unw_accessors_t
*acc
;
136 unw_regnum_t uw_sp_regnum
;
137 struct libunwind_frame_cache
*cache
;
138 struct libunwind_descr
*descr
;
139 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
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 (gdbarch
);
166 acc
= descr
->accessors
;
167 as
= unw_create_addr_space_p (acc
,
168 gdbarch_byte_order (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 (gdbarch_sp_regnum (gdbarch
));
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
;
197 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
199 struct libunwind_frame_cache
*cache
= this_cache
;
201 unw_destroy_addr_space_p (cache
->as
);
205 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
207 return unw_find_dyn_list_p (as
, di
, arg
);
210 static const struct frame_unwind libunwind_frame_unwind
=
213 libunwind_frame_this_id
,
214 libunwind_frame_prev_register
,
217 libunwind_frame_dealloc_cache
220 /* Verify if there is sufficient libunwind information for the frame to use
221 libunwind frame unwinding. */
222 const struct frame_unwind
*
223 libunwind_frame_sniffer (struct frame_info
*next_frame
)
226 unw_accessors_t
*acc
;
228 struct libunwind_descr
*descr
;
229 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
232 /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
233 up. We use this same method when setting up the frame cache (see libunwind_frame_cache()).
234 If libunwind returns success for this operation, it means that it has found sufficient
235 libunwind unwinding information to do so. */
237 descr
= libunwind_descr (gdbarch
);
238 acc
= descr
->accessors
;
239 as
= unw_create_addr_space_p (acc
,
240 gdbarch_byte_order (gdbarch
)
245 ret
= unw_init_remote_p (&cursor
, as
, next_frame
);
249 unw_destroy_addr_space_p (as
);
254 /* Check to see if we have libunwind info by checking if we are in a
255 signal frame. If it doesn't return an error, we have libunwind info
256 and can use libunwind. */
257 ret
= unw_is_signal_frame_p (&cursor
);
258 unw_destroy_addr_space_p (as
);
263 return &libunwind_frame_unwind
;
267 libunwind_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
268 struct frame_id
*this_id
)
270 struct libunwind_frame_cache
*cache
=
271 libunwind_frame_cache (next_frame
, this_cache
);
274 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
276 (*this_id
) = null_frame_id
;
280 libunwind_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
281 int regnum
, int *optimizedp
,
282 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
283 int *realnump
, gdb_byte
*valuep
)
285 struct libunwind_frame_cache
*cache
=
286 libunwind_frame_cache (next_frame
, this_cache
);
287 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
295 unw_regnum_t uw_regnum
;
296 struct libunwind_descr
*descr
;
301 /* Convert from gdb register number to libunwind register number. */
302 descr
= libunwind_descr (get_frame_arch (next_frame
));
303 uw_regnum
= descr
->gdb2uw (regnum
);
305 gdb_assert (regnum
>= 0);
307 if (!target_has_registers
)
308 error (_("No registers."));
316 memset (valuep
, 0, register_size (gdbarch
, regnum
));
321 /* To get the previous register, we use the libunwind register APIs with
322 the cursor we have already pushed back to the previous frame. */
324 if (descr
->is_fpreg (uw_regnum
))
326 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
331 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
339 memcpy (valuep
, ptr
, register_size (gdbarch
, regnum
));
341 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
351 *lvalp
= lval_memory
;
356 *lvalp
= lval_register
;
363 libunwind_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
365 struct libunwind_frame_cache
*cache
=
366 libunwind_frame_cache (next_frame
, this_cache
);
369 return (CORE_ADDR
)NULL
;
373 /* The following is a glue routine to call the libunwind unwind table
374 search function to get unwind information for a specified ip address. */
376 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
377 void *pi
, int need_unwind_info
, void *args
)
379 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
380 di
, pi
, need_unwind_info
, args
);
383 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
384 const struct frame_unwind
*
385 libunwind_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
388 unw_accessors_t
*acc
;
390 struct libunwind_descr
*descr
;
391 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
394 /* To test for libunwind unwind support, initialize a cursor to the
395 current frame and try to back up. We use this same method when
396 setting up the frame cache (see libunwind_frame_cache()). If
397 libunwind returns success for this operation, it means that it
398 has found sufficient libunwind unwinding information to do
401 descr
= libunwind_descr (gdbarch
);
402 acc
= descr
->accessors
;
403 as
= unw_create_addr_space_p (acc
,
404 gdbarch_byte_order (gdbarch
)
409 ret
= unw_init_remote_p (&cursor
, as
, next_frame
);
413 unw_destroy_addr_space_p (as
);
417 /* Check to see if we are in a signal frame. */
418 ret
= unw_is_signal_frame_p (&cursor
);
419 unw_destroy_addr_space_p (as
);
421 return &libunwind_frame_unwind
;
426 /* The following routine is for accessing special registers of the top frame.
427 A special set of accessors must be given that work without frame info.
428 This is used by ia64 to access the rse registers r32-r127. While they
429 are usually located at BOF, this is not always true and only the libunwind
430 info can decipher where they actually are. */
432 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
433 int regnum
, void *buf
)
436 unw_accessors_t
*acc
;
438 struct libunwind_descr
*descr
;
440 unw_regnum_t uw_regnum
;
446 descr
= libunwind_descr (gdbarch
);
447 acc
= descr
->special_accessors
;
448 as
= unw_create_addr_space_p (acc
,
449 gdbarch_byte_order (gdbarch
)
454 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
457 unw_destroy_addr_space_p (as
);
461 uw_regnum
= descr
->gdb2uw (regnum
);
463 if (descr
->is_fpreg (uw_regnum
))
465 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
470 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
474 unw_destroy_addr_space_p (as
);
480 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
486 libunwind_load (void)
490 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
494 /* Initialize pointers to the dynamic library functions we will use. */
496 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
497 if (unw_get_reg_p
== NULL
)
500 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
501 if (unw_get_fpreg_p
== NULL
)
504 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
505 if (unw_get_saveloc_p
== NULL
)
508 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
509 if (unw_is_signal_frame_p
== NULL
)
512 unw_step_p
= dlsym (handle
, step_name
);
513 if (unw_step_p
== NULL
)
516 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
517 if (unw_init_remote_p
== NULL
)
520 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
521 if (unw_create_addr_space_p
== NULL
)
524 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
525 if (unw_destroy_addr_space_p
== NULL
)
528 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
529 if (unw_search_unwind_table_p
== NULL
)
532 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
533 if (unw_find_dyn_list_p
== NULL
)
540 libunwind_is_initialized (void)
542 return libunwind_initialized
;
545 /* Provide a prototype to silence -Wmissing-prototypes. */
546 void _initialize_libunwind_frame (void);
549 _initialize_libunwind_frame (void)
551 libunwind_descr_handle
= gdbarch_data_register_post_init (libunwind_descr_init
);
553 libunwind_initialized
= libunwind_load ();