]> Git Repo - binutils.git/blob - gdb/ia64-libunwind-tdep.c
Automatic date update in version.in
[binutils.git] / gdb / ia64-libunwind-tdep.c
1 /* Frame unwinder for ia64 frames using the libunwind library.
2
3    Copyright (C) 2003-2022 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
58 static int libunwind_initialized;
59 static const registry<gdbarch>::key<libunwind_descr> libunwind_descr_handle;
60
61 /* Required function pointers from libunwind.  */
62 typedef int (unw_get_reg_p_ftype) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
63 static unw_get_reg_p_ftype *unw_get_reg_p;
64 typedef int (unw_get_fpreg_p_ftype) (unw_cursor_t *, unw_regnum_t,
65                                      unw_fpreg_t *);
66 static unw_get_fpreg_p_ftype *unw_get_fpreg_p;
67 typedef int (unw_get_saveloc_p_ftype) (unw_cursor_t *, unw_regnum_t,
68                                        unw_save_loc_t *);
69 static unw_get_saveloc_p_ftype *unw_get_saveloc_p;
70 typedef int (unw_is_signal_frame_p_ftype) (unw_cursor_t *);
71 static unw_is_signal_frame_p_ftype *unw_is_signal_frame_p;
72 typedef int (unw_step_p_ftype) (unw_cursor_t *);
73 static unw_step_p_ftype *unw_step_p;
74 typedef int (unw_init_remote_p_ftype) (unw_cursor_t *, unw_addr_space_t,
75                                        void *);
76 static unw_init_remote_p_ftype *unw_init_remote_p;
77 typedef unw_addr_space_t (unw_create_addr_space_p_ftype) (unw_accessors_t *,
78                                                           int);
79 static unw_create_addr_space_p_ftype *unw_create_addr_space_p;
80 typedef void (unw_destroy_addr_space_p_ftype) (unw_addr_space_t);
81 static unw_destroy_addr_space_p_ftype *unw_destroy_addr_space_p;
82 typedef 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 *);
85 static unw_search_unwind_table_p_ftype *unw_search_unwind_table_p;
86 typedef unw_word_t (unw_find_dyn_list_p_ftype) (unw_addr_space_t,
87                                                 unw_dyn_info_t *, void *);
88 static unw_find_dyn_list_p_ftype *unw_find_dyn_list_p;
89
90
91 struct libunwind_frame_cache
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
113 static const char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
114 static const char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
115 static const char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
116 static const char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
117 static const char *step_name = STRINGIFY(UNW_OBJ(step));
118 static const char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
119 static const char *create_addr_space_name
120   = STRINGIFY(UNW_OBJ(create_addr_space));
121 static const char *destroy_addr_space_name
122   = STRINGIFY(UNW_OBJ(destroy_addr_space));
123 static const char *search_unwind_table_name
124   = STRINGIFY(UNW_OBJ(search_unwind_table));
125 static const char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
126
127 static struct libunwind_descr *
128 libunwind_descr (struct gdbarch *gdbarch)
129 {
130   struct libunwind_descr *result = libunwind_descr_handle.get (gdbarch);
131   if (result == nullptr)
132     result = libunwind_descr_handle.emplace (gdbarch);
133   return result;
134 }
135
136 void
137 libunwind_frame_set_descr (struct gdbarch *gdbarch,
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
155 static struct libunwind_frame_cache *
156 libunwind_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.  */
171   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_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,
202                                  gdbarch_byte_order (gdbarch)
203                                  == BFD_ENDIAN_BIG
204                                  ? __BIG_ENDIAN
205                                  : __LITTLE_ENDIAN);
206
207   unw_init_remote_p (&cache->cursor, as, this_frame);
208   if (unw_step_p (&cache->cursor) < 0)
209     {
210       unw_destroy_addr_space_p (as);
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     {
219       unw_destroy_addr_space_p (as);
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
230 void
231 libunwind_frame_dealloc_cache (frame_info_ptr self, void *this_cache)
232 {
233   struct libunwind_frame_cache *cache
234     = (struct libunwind_frame_cache *) this_cache;
235
236   if (cache->as)
237     unw_destroy_addr_space_p (cache->as);
238 }
239
240 unw_word_t
241 libunwind_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.  */
248 int
249 libunwind_frame_sniffer (const struct frame_unwind *self,
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,
268                                  gdbarch_byte_order (gdbarch)
269                                  == BFD_ENDIAN_BIG
270                                  ? __BIG_ENDIAN
271                                  : __LITTLE_ENDIAN);
272
273   ret = unw_init_remote_p (&cursor, as, this_frame);
274
275   if (ret < 0)
276     {
277       unw_destroy_addr_space_p (as);
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);
286   unw_destroy_addr_space_p (as);
287
288   if (ret < 0)
289     return 0;
290
291   return 1;
292 }
293
294 void
295 libunwind_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
305 struct value *
306 libunwind_frame_prev_register (frame_info_ptr this_frame,
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.  */ 
377 int
378 libunwind_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.  */
388 int
389 libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
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,
410                                  gdbarch_byte_order (gdbarch)
411                                  == BFD_ENDIAN_BIG
412                                  ? __BIG_ENDIAN
413                                  : __LITTLE_ENDIAN);
414
415   ret = unw_init_remote_p (&cursor, as, this_frame);
416
417   if (ret < 0)
418     {
419       unw_destroy_addr_space_p (as);
420       return 0;
421     }
422
423   /* Check to see if we are in a signal frame.  */
424   ret = unw_is_signal_frame_p (&cursor);
425   unw_destroy_addr_space_p (as);
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.  */
437 int
438 libunwind_get_reg_special (struct gdbarch *gdbarch, readable_regcache *regcache,
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,
455                                  gdbarch_byte_order (gdbarch)
456                                  == BFD_ENDIAN_BIG
457                                  ? __BIG_ENDIAN
458                                  : __LITTLE_ENDIAN);
459
460   ret = unw_init_remote_p (&cursor, as, regcache);
461   if (ret < 0)
462     {
463       unw_destroy_addr_space_p (as);
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
480   unw_destroy_addr_space_p (as);
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   
491 static int
492 libunwind_load (void)
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
524   unw_get_fpreg_p = (unw_get_fpreg_p_ftype *) dlsym (handle, get_fpreg_name);
525   if (unw_get_fpreg_p == NULL)
526     return 0;
527
528   unw_get_saveloc_p
529     = (unw_get_saveloc_p_ftype *) dlsym (handle, get_saveloc_name);
530   if (unw_get_saveloc_p == NULL)
531     return 0;
532
533   unw_is_signal_frame_p
534     = (unw_is_signal_frame_p_ftype *) dlsym (handle, is_signal_frame_name);
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
542   unw_init_remote_p
543     = (unw_init_remote_p_ftype *) dlsym (handle, init_remote_name);
544   if (unw_init_remote_p == NULL)
545     return 0;
546
547   unw_create_addr_space_p
548     = (unw_create_addr_space_p_ftype *) dlsym (handle, create_addr_space_name);
549   if (unw_create_addr_space_p == NULL)
550     return 0;
551
552   unw_destroy_addr_space_p
553     = (unw_destroy_addr_space_p_ftype *) dlsym (handle,
554                                                 destroy_addr_space_name);
555   if (unw_destroy_addr_space_p == NULL)
556     return 0;
557
558   unw_search_unwind_table_p
559     = (unw_search_unwind_table_p_ftype *) dlsym (handle,
560                                                  search_unwind_table_name);
561   if (unw_search_unwind_table_p == NULL)
562     return 0;
563
564   unw_find_dyn_list_p
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
572 int
573 libunwind_is_initialized (void)
574 {
575   return libunwind_initialized;
576 }
577
578 void _initialize_libunwind_frame ();
579 void
580 _initialize_libunwind_frame ()
581 {
582   libunwind_initialized = libunwind_load ();
583 }
This page took 0.055268 seconds and 4 git commands to generate.