GDB (xrefs)
Loading...
Searching...
No Matches
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-2023 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 "gdbsupport/preprocessor.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. */
62typedef int (unw_get_reg_p_ftype) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
64typedef int (unw_get_fpreg_p_ftype) (unw_cursor_t *, unw_regnum_t,
65 unw_fpreg_t *);
67typedef int (unw_get_saveloc_p_ftype) (unw_cursor_t *, unw_regnum_t,
68 unw_save_loc_t *);
70typedef int (unw_is_signal_frame_p_ftype) (unw_cursor_t *);
72typedef int (unw_step_p_ftype) (unw_cursor_t *);
74typedef int (unw_init_remote_p_ftype) (unw_cursor_t *, unw_addr_space_t,
75 void *);
77typedef unw_addr_space_t (unw_create_addr_space_p_ftype) (unw_accessors_t *,
78 int);
80typedef void (unw_destroy_addr_space_p_ftype) (unw_addr_space_t);
82typedef int (unw_search_unwind_table_p_ftype) (unw_addr_space_t, unw_word_t,
83 unw_dyn_info_t *,
84 unw_proc_info_t *, int, void *);
86typedef unw_word_t (unw_find_dyn_list_p_ftype) (unw_addr_space_t,
87 unw_dyn_info_t *, void *);
89
90
92{
93 CORE_ADDR base;
94 CORE_ADDR func_addr;
95 unw_cursor_t cursor;
96 unw_addr_space_t as;
97};
98
99/* We need to qualify the function names with a platform-specific prefix
100 to match the names used by the libunwind library. The UNW_OBJ macro is
101 provided by the libunwind.h header file. */
102
103#ifndef LIBUNWIND_SO
104/* Use the stable ABI major version number. `libunwind-ia64.so' is a link time
105 only library, not a runtime one. */
106#define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"
107
108/* Provide also compatibility with older .so. The two APIs are compatible, .8
109 is only extended a bit, GDB does not use the extended API at all. */
110#define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
111#endif
112
113static const char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
114static const char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
115static const char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
116static const char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
117static const char *step_name = STRINGIFY(UNW_OBJ(step));
118static const char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
119static const char *create_addr_space_name
120 = STRINGIFY(UNW_OBJ(create_addr_space));
121static const char *destroy_addr_space_name
122 = STRINGIFY(UNW_OBJ(destroy_addr_space));
123static const char *search_unwind_table_name
124 = STRINGIFY(UNW_OBJ(search_unwind_table));
125static const char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
126
127static struct libunwind_descr *
129{
131 if (result == nullptr)
132 result = libunwind_descr_handle.emplace (gdbarch);
133 return result;
134}
135
136void
138 struct libunwind_descr *descr)
139{
140 struct libunwind_descr *arch_descr;
141
142 gdb_assert (gdbarch != NULL);
143
144 arch_descr = libunwind_descr (gdbarch);
145 gdb_assert (arch_descr != NULL);
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
155static struct libunwind_frame_cache *
156libunwind_frame_cache (frame_info_ptr 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 ret;
166
167 if (*this_cache)
168 return (struct libunwind_frame_cache *) *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 abandoning 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 = (unw_accessors_t *) descr->accessors;
201 as = unw_create_addr_space_p (acc,
203 == BFD_ENDIAN_BIG
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
230void
232{
233 struct libunwind_frame_cache *cache
234 = (struct libunwind_frame_cache *) this_cache;
235
236 if (cache->as)
238}
239
240unw_word_t
241libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
242{
243 return unw_find_dyn_list_p (as, di, arg);
244}
245
246/* Verify if there is sufficient libunwind information for the frame to use
247 libunwind frame unwinding. */
248int
250 frame_info_ptr this_frame, void **this_cache)
251{
252 unw_cursor_t cursor;
253 unw_accessors_t *acc;
254 unw_addr_space_t as;
255 struct libunwind_descr *descr;
256 struct gdbarch *gdbarch = get_frame_arch (this_frame);
257 int ret;
258
259 /* To test for libunwind unwind support, initialize a cursor to
260 the current frame and try to back up. We use this same method
261 when setting up the frame cache (see libunwind_frame_cache()).
262 If libunwind returns success for this operation, it means that
263 it has found sufficient libunwind unwinding information to do so. */
264
265 descr = libunwind_descr (gdbarch);
266 acc = (unw_accessors_t *) descr->accessors;
267 as = unw_create_addr_space_p (acc,
269 == BFD_ENDIAN_BIG
272
273 ret = unw_init_remote_p (&cursor, as, this_frame);
274
275 if (ret < 0)
276 {
278 return 0;
279 }
280
281
282 /* Check to see if we have libunwind info by checking if we are in a
283 signal frame. If it doesn't return an error, we have libunwind info
284 and can use libunwind. */
285 ret = unw_is_signal_frame_p (&cursor);
287
288 if (ret < 0)
289 return 0;
290
291 return 1;
292}
293
294void
295libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
296 struct frame_id *this_id)
297{
298 struct libunwind_frame_cache *cache =
299 libunwind_frame_cache (this_frame, this_cache);
300
301 if (cache != NULL)
302 (*this_id) = frame_id_build (cache->base, cache->func_addr);
303}
304
305struct value *
307 void **this_cache, int regnum)
308{
309 struct libunwind_frame_cache *cache =
310 libunwind_frame_cache (this_frame, this_cache);
311
312 unw_save_loc_t sl;
313 int ret;
314 unw_word_t intval;
315 unw_fpreg_t fpval;
316 unw_regnum_t uw_regnum;
317 struct libunwind_descr *descr;
318 struct value *val = NULL;
319
320 if (cache == NULL)
321 return frame_unwind_got_constant (this_frame, regnum, 0);
322
323 /* Convert from gdb register number to libunwind register number. */
324 descr = libunwind_descr (get_frame_arch (this_frame));
325 uw_regnum = descr->gdb2uw (regnum);
326
327 gdb_assert (regnum >= 0);
328
329 if (!target_has_registers ())
330 error (_("No registers."));
331
332 if (uw_regnum < 0)
333 return frame_unwind_got_constant (this_frame, regnum, 0);
334
335 if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
336 return frame_unwind_got_constant (this_frame, regnum, 0);
337
338 switch (sl.type)
339 {
340 case UNW_SLT_MEMORY:
341 val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
342 break;
343
344 case UNW_SLT_REG:
345 val = frame_unwind_got_register (this_frame, regnum,
346 descr->uw2gdb (sl.u.regnum));
347 break;
348 case UNW_SLT_NONE:
349 {
350 /* The register is not stored at a specific memory address nor
351 inside another register. So use libunwind to fetch the register
352 value for us, and create a constant value with the result. */
353 if (descr->is_fpreg (uw_regnum))
354 {
355 ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
356 if (ret < 0)
357 return frame_unwind_got_constant (this_frame, regnum, 0);
358 val = frame_unwind_got_bytes (this_frame, regnum,
359 (gdb_byte *) &fpval);
360 }
361 else
362 {
363 ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
364 if (ret < 0)
365 return frame_unwind_got_constant (this_frame, regnum, 0);
366 val = frame_unwind_got_constant (this_frame, regnum, intval);
367 }
368 break;
369 }
370 }
371
372 return val;
373}
374
375/* The following is a glue routine to call the libunwind unwind table
376 search function to get unwind information for a specified ip address. */
377int
378libunwind_search_unwind_table (void *as, long ip, void *di,
379 void *pi, int need_unwind_info, void *args)
380{
381 return unw_search_unwind_table_p (*(unw_addr_space_t *) as, (unw_word_t) ip,
382 (unw_dyn_info_t *) di,
383 (unw_proc_info_t *) pi, need_unwind_info,
384 args);
385}
386
387/* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
388int
390 frame_info_ptr 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 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 = (unw_accessors_t *) descr->accessors;
409 as = unw_create_addr_space_p (acc,
411 == BFD_ENDIAN_BIG
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. */
437int
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 = (unw_accessors_t *) descr->special_accessors;
454 as = unw_create_addr_space_p (acc,
456 == BFD_ENDIAN_BIG
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
491static 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 gdb_printf (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
508 LIBUNWIND_SO, so_error);
509#ifdef LIBUNWIND_SO_7
510 gdb_printf (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 = (unw_get_reg_p_ftype *) dlsym (handle, get_reg_name);
521 if (unw_get_reg_p == NULL)
522 return 0;
523
525 if (unw_get_fpreg_p == NULL)
526 return 0;
527
529 = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name);
530 if (unw_get_saveloc_p == NULL)
531 return 0;
532
535 if (unw_is_signal_frame_p == NULL)
536 return 0;
537
538 unw_step_p = (unw_step_p_ftype *) dlsym (handle, step_name);
539 if (unw_step_p == NULL)
540 return 0;
541
543 = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name);
544 if (unw_init_remote_p == NULL)
545 return 0;
546
549 if (unw_create_addr_space_p == NULL)
550 return 0;
551
553 = (unw_destroy_addr_space_p_ftype *) dlsym (handle,
555 if (unw_destroy_addr_space_p == NULL)
556 return 0;
557
559 = (unw_search_unwind_table_p_ftype *) dlsym (handle,
561 if (unw_search_unwind_table_p == NULL)
562 return 0;
563
565 = (unw_find_dyn_list_p_ftype *) dlsym (handle, find_dyn_list_name);
566 if (unw_find_dyn_list_p == NULL)
567 return 0;
568
569 return 1;
570}
571
572int
577
579void
int regnum
void xfree(void *)
void * get(unsigned key)
Definition registry.h:211
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
struct value * frame_unwind_got_bytes(frame_info_ptr frame, int regnum, const gdb_byte *buf)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2037
int unw_get_reg_p_ftype(unw_cursor_t *, unw_regnum_t, unw_word_t *)
struct value * libunwind_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
int unw_search_unwind_table_p_ftype(unw_addr_space_t, unw_word_t, unw_dyn_info_t *, unw_proc_info_t *, int, void *)
static const char * get_fpreg_name
static const char * find_dyn_list_name
static const char * get_saveloc_name
static struct libunwind_descr * libunwind_descr(struct gdbarch *gdbarch)
static unw_get_reg_p_ftype * unw_get_reg_p
int unw_is_signal_frame_p_ftype(unw_cursor_t *)
unw_word_t libunwind_find_dyn_list(unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
static unw_destroy_addr_space_p_ftype * unw_destroy_addr_space_p
static unw_is_signal_frame_p_ftype * unw_is_signal_frame_p
static const char * step_name
static unw_find_dyn_list_p_ftype * unw_find_dyn_list_p
static unw_create_addr_space_p_ftype * unw_create_addr_space_p
int libunwind_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
static struct libunwind_frame_cache * libunwind_frame_cache(frame_info_ptr this_frame, void **this_cache)
int unw_init_remote_p_ftype(unw_cursor_t *, unw_addr_space_t, void *)
unw_word_t unw_find_dyn_list_p_ftype(unw_addr_space_t, unw_dyn_info_t *, void *)
static unw_get_fpreg_p_ftype * unw_get_fpreg_p
static unw_init_remote_p_ftype * unw_init_remote_p
static unw_search_unwind_table_p_ftype * unw_search_unwind_table_p
static int libunwind_load(void)
void libunwind_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
int unw_get_saveloc_p_ftype(unw_cursor_t *, unw_regnum_t, unw_save_loc_t *)
int unw_get_fpreg_p_ftype(unw_cursor_t *, unw_regnum_t, unw_fpreg_t *)
#define LIBUNWIND_SO_7
static unw_get_saveloc_p_ftype * unw_get_saveloc_p
int libunwind_search_unwind_table(void *as, long ip, void *di, void *pi, int need_unwind_info, void *args)
static int libunwind_initialized
#define __BIG_ENDIAN
static const char * is_signal_frame_name
int libunwind_get_reg_special(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, void *buf)
int libunwind_sigtramp_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
void libunwind_frame_dealloc_cache(frame_info_ptr self, void *this_cache)
void _initialize_libunwind_frame()
static const char * destroy_addr_space_name
static const char * create_addr_space_name
#define LIBUNWIND_SO
int unw_step_p_ftype(unw_cursor_t *)
static const char * search_unwind_table_name
int libunwind_is_initialized(void)
unw_addr_space_t unw_create_addr_space_p_ftype(unw_accessors_t *, int)
void libunwind_frame_set_descr(struct gdbarch *gdbarch, struct libunwind_descr *descr)
void unw_destroy_addr_space_p_ftype(unw_addr_space_t)
static const registry< gdbarch >::key< libunwind_descr > libunwind_descr_handle
#define __LITTLE_ENDIAN
static unw_step_p_ftype * unw_step_p
static const char * init_remote_name
static const char * get_reg_name
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
Definition value.h:130
int target_has_registers()
Definition target.c:189
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187