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 default_frame_unwind_stop_reason
,
241 libunwind_frame_this_id
,
242 libunwind_frame_prev_register
,
244 libunwind_frame_sniffer
,
245 libunwind_frame_dealloc_cache
,
248 /* Verify if there is sufficient libunwind information for the frame to use
249 libunwind frame unwinding. */
251 libunwind_frame_sniffer (const struct frame_unwind
*self
,
252 struct frame_info
*this_frame
, void **this_cache
)
255 unw_accessors_t
*acc
;
257 struct libunwind_descr
*descr
;
258 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
261 /* To test for libunwind unwind support, initialize a cursor to
262 the current frame and try to back up. We use this same method
263 when setting up the frame cache (see libunwind_frame_cache()).
264 If libunwind returns success for this operation, it means that
265 it has found sufficient libunwind unwinding information to do so. */
267 descr
= libunwind_descr (gdbarch
);
268 acc
= descr
->accessors
;
269 as
= unw_create_addr_space_p (acc
,
270 gdbarch_byte_order (gdbarch
)
275 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
279 unw_destroy_addr_space_p (as
);
284 /* Check to see if we have libunwind info by checking if we are in a
285 signal frame. If it doesn't return an error, we have libunwind info
286 and can use libunwind. */
287 ret
= unw_is_signal_frame_p (&cursor
);
288 unw_destroy_addr_space_p (as
);
297 libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
298 struct frame_id
*this_id
)
300 struct libunwind_frame_cache
*cache
=
301 libunwind_frame_cache (this_frame
, this_cache
);
304 (*this_id
) = frame_id_build (cache
->base
, cache
->func_addr
);
308 libunwind_frame_prev_register (struct frame_info
*this_frame
,
309 void **this_cache
, int regnum
)
311 struct libunwind_frame_cache
*cache
=
312 libunwind_frame_cache (this_frame
, this_cache
);
313 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
321 unw_regnum_t uw_regnum
;
322 struct libunwind_descr
*descr
;
323 struct value
*val
= NULL
;
326 return frame_unwind_got_constant (this_frame
, regnum
, 0);
328 /* Convert from gdb register number to libunwind register number. */
329 descr
= libunwind_descr (get_frame_arch (this_frame
));
330 uw_regnum
= descr
->gdb2uw (regnum
);
332 gdb_assert (regnum
>= 0);
334 if (!target_has_registers
)
335 error (_("No registers."));
338 return frame_unwind_got_constant (this_frame
, regnum
, 0);
340 if (unw_get_saveloc_p (&cache
->cursor
, uw_regnum
, &sl
) < 0)
341 return frame_unwind_got_constant (this_frame
, regnum
, 0);
346 val
= frame_unwind_got_memory (this_frame
, regnum
, sl
.u
.addr
);
350 val
= frame_unwind_got_register (this_frame
, regnum
,
351 descr
->uw2gdb (sl
.u
.regnum
));
355 /* The register is not stored at a specific memory address nor
356 inside another register. So use libunwind to fetch the register
357 value for us, and create a constant value with the result. */
358 if (descr
->is_fpreg (uw_regnum
))
360 ret
= unw_get_fpreg_p (&cache
->cursor
, uw_regnum
, &fpval
);
362 return frame_unwind_got_constant (this_frame
, regnum
, 0);
363 val
= frame_unwind_got_bytes (this_frame
, regnum
,
364 (gdb_byte
*) &fpval
);
368 ret
= unw_get_reg_p (&cache
->cursor
, uw_regnum
, &intval
);
370 return frame_unwind_got_constant (this_frame
, regnum
, 0);
371 val
= frame_unwind_got_constant (this_frame
, regnum
, intval
);
381 libunwind_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
383 struct libunwind_frame_cache
*cache
=
384 libunwind_frame_cache (this_frame
, this_cache
);
387 return (CORE_ADDR
)NULL
;
391 /* The following is a glue routine to call the libunwind unwind table
392 search function to get unwind information for a specified ip address. */
394 libunwind_search_unwind_table (void *as
, long ip
, void *di
,
395 void *pi
, int need_unwind_info
, void *args
)
397 return unw_search_unwind_table_p (*(unw_addr_space_t
*)as
, (unw_word_t
)ip
,
398 di
, pi
, need_unwind_info
, args
);
401 /* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
403 libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
404 struct frame_info
*this_frame
,
408 unw_accessors_t
*acc
;
410 struct libunwind_descr
*descr
;
411 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
414 /* To test for libunwind unwind support, initialize a cursor to the
415 current frame and try to back up. We use this same method when
416 setting up the frame cache (see libunwind_frame_cache()). If
417 libunwind returns success for this operation, it means that it
418 has found sufficient libunwind unwinding information to do
421 descr
= libunwind_descr (gdbarch
);
422 acc
= descr
->accessors
;
423 as
= unw_create_addr_space_p (acc
,
424 gdbarch_byte_order (gdbarch
)
429 ret
= unw_init_remote_p (&cursor
, as
, this_frame
);
433 unw_destroy_addr_space_p (as
);
437 /* Check to see if we are in a signal frame. */
438 ret
= unw_is_signal_frame_p (&cursor
);
439 unw_destroy_addr_space_p (as
);
446 /* The following routine is for accessing special registers of the top frame.
447 A special set of accessors must be given that work without frame info.
448 This is used by ia64 to access the rse registers r32-r127. While they
449 are usually located at BOF, this is not always true and only the libunwind
450 info can decipher where they actually are. */
452 libunwind_get_reg_special (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
453 int regnum
, void *buf
)
456 unw_accessors_t
*acc
;
458 struct libunwind_descr
*descr
;
460 unw_regnum_t uw_regnum
;
466 descr
= libunwind_descr (gdbarch
);
467 acc
= descr
->special_accessors
;
468 as
= unw_create_addr_space_p (acc
,
469 gdbarch_byte_order (gdbarch
)
474 ret
= unw_init_remote_p (&cursor
, as
, regcache
);
477 unw_destroy_addr_space_p (as
);
481 uw_regnum
= descr
->gdb2uw (regnum
);
483 if (descr
->is_fpreg (uw_regnum
))
485 ret
= unw_get_fpreg_p (&cursor
, uw_regnum
, &fpval
);
490 ret
= unw_get_reg_p (&cursor
, uw_regnum
, &intval
);
494 unw_destroy_addr_space_p (as
);
500 memcpy (buf
, ptr
, register_size (gdbarch
, regnum
));
506 libunwind_load (void)
510 handle
= dlopen (LIBUNWIND_SO
, RTLD_NOW
);
514 /* Initialize pointers to the dynamic library functions we will use. */
516 unw_get_reg_p
= dlsym (handle
, get_reg_name
);
517 if (unw_get_reg_p
== NULL
)
520 unw_get_fpreg_p
= dlsym (handle
, get_fpreg_name
);
521 if (unw_get_fpreg_p
== NULL
)
524 unw_get_saveloc_p
= dlsym (handle
, get_saveloc_name
);
525 if (unw_get_saveloc_p
== NULL
)
528 unw_is_signal_frame_p
= dlsym (handle
, is_signal_frame_name
);
529 if (unw_is_signal_frame_p
== NULL
)
532 unw_step_p
= dlsym (handle
, step_name
);
533 if (unw_step_p
== NULL
)
536 unw_init_remote_p
= dlsym (handle
, init_remote_name
);
537 if (unw_init_remote_p
== NULL
)
540 unw_create_addr_space_p
= dlsym (handle
, create_addr_space_name
);
541 if (unw_create_addr_space_p
== NULL
)
544 unw_destroy_addr_space_p
= dlsym (handle
, destroy_addr_space_name
);
545 if (unw_destroy_addr_space_p
== NULL
)
548 unw_search_unwind_table_p
= dlsym (handle
, search_unwind_table_name
);
549 if (unw_search_unwind_table_p
== NULL
)
552 unw_find_dyn_list_p
= dlsym (handle
, find_dyn_list_name
);
553 if (unw_find_dyn_list_p
== NULL
)
560 libunwind_is_initialized (void)
562 return libunwind_initialized
;
565 /* Provide a prototype to silence -Wmissing-prototypes. */
566 void _initialize_libunwind_frame (void);
569 _initialize_libunwind_frame (void)
571 libunwind_descr_handle
572 = gdbarch_data_register_post_init (libunwind_descr_init
);
574 libunwind_initialized
= libunwind_load ();