1 /* Frame unwinder for frames using the libunwind library.
3 Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Written by Jeff Johnston, contributed by Red Hat Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "frame-base.h"
28 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "libunwind-frame.h"
42 #include "complaints.h"
44 /* The following two macros are normally defined in <endian.h>.
45 But systems such as ia64-hpux do not provide such header, so
46 we just define them here if not already defined. */
47 #ifndef __LITTLE_ENDIAN
48 #define __LITTLE_ENDIAN 1234
51 #define __BIG_ENDIAN 4321
54 static int libunwind_initialized
;
55 static struct gdbarch_data
*libunwind_descr_handle
;
57 /* Required function pointers from libunwind. */
58 static int (*unw_get_reg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_word_t
*);
59 static int (*unw_get_fpreg_p
) (unw_cursor_t
*, unw_regnum_t
, unw_fpreg_t
*);
60 static int (*unw_get_saveloc_p
) (unw_cursor_t
*, unw_regnum_t
,
62 static int (*unw_is_signal_frame_p
) (unw_cursor_t
*);
63 static int (*unw_step_p
) (unw_cursor_t
*);
64 static int (*unw_init_remote_p
) (unw_cursor_t
*, unw_addr_space_t
, void *);
65 static unw_addr_space_t (*unw_create_addr_space_p
) (unw_accessors_t
*, int);
66 static void (*unw_destroy_addr_space_p
) (unw_addr_space_t
);
67 static int (*unw_search_unwind_table_p
) (unw_addr_space_t
, unw_word_t
,
69 unw_proc_info_t
*, int, void *);
70 static unw_word_t (*unw_find_dyn_list_p
) (unw_addr_space_t
, unw_dyn_info_t
*,
74 struct libunwind_frame_cache
82 /* We need to qualify the function names with a platform-specific prefix
83 to match the names used by the libunwind library. The UNW_OBJ macro is
84 provided by the libunwind.h header file. */
85 #define STRINGIFY2(name) #name
86 #define STRINGIFY(name) STRINGIFY2(name)
89 /* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
90 only library, not a runtime one. */
91 #define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
94 static char *get_reg_name
= STRINGIFY(UNW_OBJ(get_reg
));
95 static char *get_fpreg_name
= STRINGIFY(UNW_OBJ(get_fpreg
));
96 static char *get_saveloc_name
= STRINGIFY(UNW_OBJ(get_save_loc
));
97 static char *is_signal_frame_name
= STRINGIFY(UNW_OBJ(is_signal_frame
));
98 static char *step_name
= STRINGIFY(UNW_OBJ(step
));
99 static char *init_remote_name
= STRINGIFY(UNW_OBJ(init_remote
));
100 static char *create_addr_space_name
= STRINGIFY(UNW_OBJ(create_addr_space
));
101 static char *destroy_addr_space_name
= STRINGIFY(UNW_OBJ(destroy_addr_space
));
102 static char *search_unwind_table_name
103 = STRINGIFY(UNW_OBJ(search_unwind_table
));
104 static char *find_dyn_list_name
= STRINGIFY(UNW_OBJ(find_dyn_list
));
106 static struct libunwind_descr
*
107 libunwind_descr (struct gdbarch
*gdbarch
)
109 return gdbarch_data (gdbarch
, libunwind_descr_handle
);
113 libunwind_descr_init (struct gdbarch
*gdbarch
)
115 struct libunwind_descr
*descr
116 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct libunwind_descr
);
122 libunwind_frame_set_descr (struct gdbarch
*gdbarch
,
123 struct libunwind_descr
*descr
)
125 struct libunwind_descr
*arch_descr
;
127 gdb_assert (gdbarch
!= NULL
);
129 arch_descr
= gdbarch_data (gdbarch
, libunwind_descr_handle
);
131 if (arch_descr
== NULL
)
133 /* First time here. Must initialize data area. */
134 arch_descr
= libunwind_descr_init (gdbarch
);
135 deprecated_set_gdbarch_data (gdbarch
,
136 libunwind_descr_handle
, arch_descr
);
139 /* Copy new descriptor info into arch descriptor. */
140 arch_descr
->gdb2uw
= descr
->gdb2uw
;
141 arch_descr
->uw2gdb
= descr
->uw2gdb
;
142 arch_descr
->is_fpreg
= descr
->is_fpreg
;
143 arch_descr
->accessors
= descr
->accessors
;
144 arch_descr
->special_accessors
= descr
->special_accessors
;
147 static struct libunwind_frame_cache
*
148 libunwind_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
150 unw_accessors_t
*acc
;
153 unw_regnum_t uw_sp_regnum
;
154 struct libunwind_frame_cache
*cache
;
155 struct libunwind_descr
*descr
;
156 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
162 /* Allocate a new cache. */
163 cache
= FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache
);
165 cache
->func_addr
= get_frame_func (this_frame
);
166 if (cache
->func_addr
== 0)
167 /* This can happen when the frame corresponds to a function for which
168 there is no debugging information nor any entry in the symbol table.
169 This is probably a static function for which an entry in the symbol
170 table was not created when the objfile got linked (observed in
171 libpthread.so on ia64-hpux).
173 The best we can do, in that case, is use the frame PC as the function
174 address. We don't need to give up since we still have the unwind
175 record to help us perform the unwinding. There is also another
176 compelling to continue, because abandonning now means stopping
177 the backtrace, which can never be helpful for the user. */
178 cache
->func_addr
= get_frame_pc (this_frame
);
180 /* Get a libunwind cursor to the previous frame.
182 We do this by initializing a cursor. Libunwind treats a new cursor
183 as the top of stack and will get the current register set via the
184 libunwind register accessor. Now, we provide the platform-specific
185 accessors and we set up the register accessor to use the frame
186 register unwinding interfaces so that we properly get the registers
187 for the current frame rather than the top. We then use the unw_step
188 function to move the libunwind cursor back one frame. We can later
189 use this cursor to find previous registers via the unw_get_reg
190 interface which will invoke libunwind's special logic. */
191 descr
= libunwind_descr (gdbarch
);
192 acc
= descr
->accessors
;
193 as
= unw_create_addr_space_p (acc
,
194 gdbarch_byte_order (gdbarch
)
199 unw_init_remote_p (&cache
->cursor
, as
, this_frame
);
200 if (unw_step_p (&cache
->cursor
) < 0)
202 unw_destroy_addr_space_p (as
);
206 /* To get base address, get sp from previous frame. */
207 uw_sp_regnum
= descr
->gdb2uw (gdbarch_sp_regnum (gdbarch
));
208 ret
= unw_get_reg_p (&cache
->cursor
, uw_sp_regnum
, &fp
);
211 unw_destroy_addr_space_p (as
);
212 error (_("Can't get libunwind sp register."));
215 cache
->base
= (CORE_ADDR
)fp
;
223 libunwind_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
225 struct libunwind_frame_cache
*cache
= this_cache
;
228 unw_destroy_addr_space_p (cache
->as
);
232 libunwind_find_dyn_list (unw_addr_space_t as
, unw_dyn_info_t
*di
, void *arg
)
234 return unw_find_dyn_list_p (as
, di
, arg
);
237 static const struct frame_unwind libunwind_frame_unwind
=
240 libunwind_frame_this_id
,
241 libunwind_frame_prev_register
,
243 libunwind_frame_sniffer
,
244 libunwind_frame_dealloc_cache
,
247 /* Verify if there is sufficient libunwind information for the frame to use
248 libunwind frame unwinding. */
250 libunwind_frame_sniffer (const struct frame_unwind
*self
,
251 struct frame_info
*this_frame
, void **this_cache
)
254 unw_accessors_t
*acc
;
256 struct libunwind_descr
*descr
;
257 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
260 /* To test for libunwind unwind support, initialize a cursor to
261 the current frame and try to back up. We use this same method
262 when setting up the frame cache (see libunwind_frame_cache()).
263 If libunwind returns success for this operation, it means that
264 it has found sufficient libunwind unwinding information to do so. */
266 descr
= libunwind_descr (gdbarch
);
267 acc
= descr
->accessors
;
268 as
= unw_create_addr_space_p (acc
,
269 gdbarch_byte_order (gdbarch
)
274 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
278 unw_destroy_addr_space_p (as
);
283 /* Check to see if we have libunwind info by checking if we are in a
284 signal frame. If it doesn't return an error, we have libunwind info
285 and can use libunwind. */
286 ret
= unw_is_signal_frame_p (&cursor
);
287 unw_destroy_addr_space_p (as
);
296 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
297 struct frame_id
*this_id
)
299 struct libunwind_frame_cache
*cache
=
300 libunwind_frame_cache (this_frame
, this_cache
);
303 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
307 libunwind_frame_prev_register (struct frame_info
*this_frame
,
308 void **this_cache
, int regnum
)
310 struct libunwind_frame_cache
*cache
=
311 libunwind_frame_cache (this_frame
, this_cache
);
312 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
320 unw_regnum_t uw_regnum
;
321 struct libunwind_descr
*descr
;
322 struct value
*val
= NULL
;
325 return frame_unwind_got_constant (this_frame
, regnum
, 0);
327 /* Convert from gdb register number to libunwind register number. */
328 descr
= libunwind_descr (get_frame_arch (this_frame
));
329 uw_regnum
= descr
->gdb2uw (regnum
);
331 gdb_assert (regnum
>= 0);
333 if (!target_has_registers
)
334 error (_("No registers."));
337 return frame_unwind_got_constant (this_frame
, regnum
, 0);
339 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
340 return frame_unwind_got_constant (this_frame
, regnum
, 0);
345 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
349 val
= frame_unwind_got_register (this_frame
, regnum
,
350 descr
->uw2gdb (sl
.u
.regnum
));
354 /* The register is not stored at a specific memory address nor
355 inside another register. So use libunwind to fetch the register
356 value for us, and create a constant value with the result. */
357 if (descr
->is_fpreg (uw_regnum
))
359 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
361 return frame_unwind_got_constant (this_frame
, regnum
, 0);
362 val
= frame_unwind_got_bytes (this_frame
, regnum
,
363 (gdb_byte
*) &fpval
);
367 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
369 return frame_unwind_got_constant (this_frame
, regnum
, 0);
370 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
380 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
382 struct libunwind_frame_cache
*cache
=
383 libunwind_frame_cache (this_frame
, this_cache
);
386 return (CORE_ADDR
)NULL
;
390 /* The following is a glue routine to call the libunwind unwind table
391 search function to get unwind information for a specified ip address. */
393 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
394 void *pi
, int need_unwind_info
, void *args
)
396 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
397 di
, pi
, need_unwind_info
, args
);
400 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
402 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
403 struct frame_info
*this_frame
,
407 unw_accessors_t
*acc
;
409 struct libunwind_descr
*descr
;
410 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
413 /* To test for libunwind unwind support, initialize a cursor to the
414 current frame and try to back up. We use this same method when
415 setting up the frame cache (see libunwind_frame_cache()). If
416 libunwind returns success for this operation, it means that it
417 has found sufficient libunwind unwinding information to do
420 descr
= libunwind_descr (gdbarch
);
421 acc
= descr
->accessors
;
422 as
= unw_create_addr_space_p (acc
,
423 gdbarch_byte_order (gdbarch
)
428 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
432 unw_destroy_addr_space_p (as
);
436 /* Check to see if we are in a signal frame. */
437 ret
= unw_is_signal_frame_p (&cursor
);
438 unw_destroy_addr_space_p (as
);
445 /* The following routine is for accessing special registers of the top frame.
446 A special set of accessors must be given that work without frame info.
447 This is used by ia64 to access the rse registers r32-r127. While they
448 are usually located at BOF, this is not always true and only the libunwind
449 info can decipher where they actually are. */
451 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
452 int regnum
, void *buf
)
455 unw_accessors_t
*acc
;
457 struct libunwind_descr
*descr
;
459 unw_regnum_t uw_regnum
;
465 descr
= libunwind_descr (gdbarch
);
466 acc
= descr
->special_accessors
;
467 as
= unw_create_addr_space_p (acc
,
468 gdbarch_byte_order (gdbarch
)
473 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
476 unw_destroy_addr_space_p (as
);
480 uw_regnum
= descr
->gdb2uw (regnum
);
482 if (descr
->is_fpreg (uw_regnum
))
484 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
489 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
493 unw_destroy_addr_space_p (as
);
499 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
505 libunwind_load (void)
509 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
513 /* Initialize pointers to the dynamic library functions we will use. */
515 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
516 if (unw_get_reg_p
== NULL
)
519 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
520 if (unw_get_fpreg_p
== NULL
)
523 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
524 if (unw_get_saveloc_p
== NULL
)
527 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
528 if (unw_is_signal_frame_p
== NULL
)
531 unw_step_p
= dlsym (handle
, step_name
);
532 if (unw_step_p
== NULL
)
535 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
536 if (unw_init_remote_p
== NULL
)
539 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
540 if (unw_create_addr_space_p
== NULL
)
543 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
544 if (unw_destroy_addr_space_p
== NULL
)
547 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
548 if (unw_search_unwind_table_p
== NULL
)
551 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
552 if (unw_find_dyn_list_p
== NULL
)
559 libunwind_is_initialized (void)
561 return libunwind_initialized
;
564 /* Provide a prototype to silence -Wmissing-prototypes. */
565 void _initialize_libunwind_frame (void);
568 _initialize_libunwind_frame (void)
570 libunwind_descr_handle
571 = gdbarch_data_register_post_init (libunwind_descr_init
);
573 libunwind_initialized
= libunwind_load ();