gdb/ia64-libunwind-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Frame unwinder for ia64 frames using the libunwind library.

  3.    Copyright (C) 2003-2015 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/>.  */

  22. #include "defs.h"

  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"

  34. #include <dlfcn.h>

  36. #include "ia64-libunwind-tdep.h"

  38. #include "complaints.h"

  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).  */

  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

  58. ‌static int libunwind_initialized;
  59. ‌static struct gdbarch_data *libunwind_descr_handle;

  61. /* Required function pointers from libunwind.  */
  62. ‌static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
  63. ‌static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
  64. ‌static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t,
  65.                                  unw_save_loc_t *);
  66. ‌static int (*unw_is_signal_frame_p) (unw_cursor_t *);
  67. ‌static int (*unw_step_p) (unw_cursor_t *);
  68. ‌static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
  69. ‌static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
  70. ‌static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
  71. ‌static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t,
  72.                                          unw_dyn_info_t *,
  73.                                          unw_proc_info_t *, int, void *);
  74. ‌static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
  75.                                           void *);


  78. ‌struct libunwind_frame_cache
  79. {
  80.   CORE_ADDR base;
  81.   CORE_ADDR func_addr;
  82.   unw_cursor_t cursor;
  83.   unw_addr_space_t as;
  84. };

  86. /* We need to qualify the function names with a platform-specific prefix
  87.    to match the names used by the libunwind library.  The UNW_OBJ macro is
  88.    provided by the libunwind.h header file.  */
  89. ‌#define STRINGIFY2(name)        #name
  90. ‌#define STRINGIFY(name)                STRINGIFY2(name)

  92. #ifndef LIBUNWIND_SO
  93. /* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
  94.    only library, not a runtime one.  */
  95. ‌#define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.8"

  97. /* Provide also compatibility with older .so.  The two APIs are compatible, .8
  98.    is only extended a bit, GDB does not use the extended API at all.  */
  99. ‌#define LIBUNWIND_SO_7 "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
  100. #endif

  102. ‌static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
  103. ‌static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
  104. ‌static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
  105. ‌static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
  106. ‌static char *step_name = STRINGIFY(UNW_OBJ(step));
  107. ‌static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
  108. ‌static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
  109. ‌static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
  110. ‌static char *search_unwind_table_name
  111.   = STRINGIFY(UNW_OBJ(search_unwind_table));
  112. ‌static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));

  114. static struct libunwind_descr *
  115. ‌libunwind_descr (struct gdbarch *gdbarch)
  116. {
  117.   return gdbarch_data (gdbarch, libunwind_descr_handle);
  118. }

  120. static void *
  121. ‌libunwind_descr_init (struct gdbarch *gdbarch)
  122. {
  123.   struct libunwind_descr *descr
  124.     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct libunwind_descr);

  126.   return descr;
  127. }

  129. void
  130. ‌libunwind_frame_set_descr (struct gdbarch *gdbarch,
  131.                            struct libunwind_descr *descr)
  132. {
  133.   struct libunwind_descr *arch_descr;

  135.   gdb_assert (gdbarch != NULL);

  137.   arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);

  139.   if (arch_descr == NULL)
  140.     {
  141.       /* First time here.  Must initialize data area.  */
  142.       arch_descr = libunwind_descr_init (gdbarch);
  143.       deprecated_set_gdbarch_data (gdbarch,
  144.                                    libunwind_descr_handle, arch_descr);
  145.     }

  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. }

  155. static struct libunwind_frame_cache *
  156. ‌libunwind_frame_cache (struct frame_info *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 i, ret;

  167.   if (*this_cache)
  168.     return *this_cache;

  170.   /* Allocate a new cache.  */
  171.   cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);

  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).

  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 abandonning now means stopping
  185.        the backtrace, which can never be helpful for the user.  */
  186.     cache->func_addr = get_frame_pc (this_frame);

  188.   /* Get a libunwind cursor to the previous frame.

  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 = 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);

  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.     }

  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.     }

  223.   cache->base = (CORE_ADDR)fp;
  224.   cache->as = as;

  226.   *this_cache = cache;
  227.   return cache;
  228. }

  230. void
  231. ‌libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
  232. {
  233.   struct libunwind_frame_cache *cache = this_cache;

  235.   if (cache->as)
  236.     unw_destroy_addr_space_p (cache->as);
  237. }

  239. unw_word_t
  240. ‌libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
  241. {
  242.   return unw_find_dyn_list_p (as, di, arg);
  243. }

  245. /* Verify if there is sufficient libunwind information for the frame to use
  246.    libunwind frame unwinding.  */
  247. int
  248. ‌libunwind_frame_sniffer (const struct frame_unwind *self,
  249.                          struct frame_info *this_frame, void **this_cache)
  250. {
  251.   unw_cursor_t cursor;
  252.   unw_accessors_t *acc;
  253.   unw_addr_space_t as;
  254.   struct libunwind_descr *descr;
  255.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  256.   int i, ret;

  258.   /* To test for libunwind unwind support, initialize a cursor to
  259.      the current frame and try to back up.  We use this same method
  260.      when setting up the frame cache (see libunwind_frame_cache()).
  261.      If libunwind returns success for this operation, it means that
  262.      it has found sufficient libunwind unwinding information to do so.  */

  264.   descr = libunwind_descr (gdbarch);
  265.   acc = descr->accessors;
  266.   as =  unw_create_addr_space_p (acc,
  267.                                  gdbarch_byte_order (gdbarch)
  268.                                  == BFD_ENDIAN_BIG
  269.                                  ? __BIG_ENDIAN
  270.                                  : __LITTLE_ENDIAN);

  272.   ret = unw_init_remote_p (&cursor, as, this_frame);

  274.   if (ret < 0)
  275.     {
  276.       unw_destroy_addr_space_p (as);
  277.       return 0;
  278.     }


  281.   /* Check to see if we have libunwind info by checking if we are in a
  282.      signal frame.  If it doesn't return an error, we have libunwind info
  283.      and can use libunwind.  */
  284.   ret = unw_is_signal_frame_p (&cursor);
  285.   unw_destroy_addr_space_p (as);

  287.   if (ret < 0)
  288.     return 0;

  290.   return 1;
  291. }

  293. void
  294. ‌libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
  295.                          struct frame_id *this_id)
  296. {
  297.   struct libunwind_frame_cache *cache =
  298.     libunwind_frame_cache (this_frame, this_cache);

  300.   if (cache != NULL)
  301.     (*this_id) = frame_id_build (cache->base, cache->func_addr);
  302. }

  304. struct value *
  305. ‌libunwind_frame_prev_register (struct frame_info *this_frame,
  306.                                void **this_cache, int regnum)
  307. {
  308.   struct libunwind_frame_cache *cache =
  309.     libunwind_frame_cache (this_frame, this_cache);
  310.   struct gdbarch *gdbarch = get_frame_arch (this_frame);

  312.   void *ptr;
  313.   unw_cursor_t *c;
  314.   unw_save_loc_t sl;
  315.   int i, ret;
  316.   unw_word_t intval;
  317.   unw_fpreg_t fpval;
  318.   unw_regnum_t uw_regnum;
  319.   struct libunwind_descr *descr;
  320.   struct value *val = NULL;

  322.   if (cache == NULL)
  323.     return frame_unwind_got_constant (this_frame, regnum, 0);

  325.   /* Convert from gdb register number to libunwind register number.  */
  326.   descr = libunwind_descr (get_frame_arch (this_frame));
  327.   uw_regnum = descr->gdb2uw (regnum);

  329.   gdb_assert (regnum >= 0);

  331.   if (!target_has_registers)
  332.     error (_("No registers."));

  334.   if (uw_regnum < 0)
  335.     return frame_unwind_got_constant (this_frame, regnum, 0);

  337.   if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
  338.     return frame_unwind_got_constant (this_frame, regnum, 0);

  340.   switch (sl.type)
  341.     {
  342.     case UNW_SLT_MEMORY:
  343.       val = frame_unwind_got_memory (this_frame, regnum, sl.u.addr);
  344.       break;

  346.     case UNW_SLT_REG:
  347.       val = frame_unwind_got_register (this_frame, regnum,
  348.                                        descr->uw2gdb (sl.u.regnum));
  349.       break;
  350.     case UNW_SLT_NONE:
  351.       {
  352.         /* The register is not stored at a specific memory address nor
  353.            inside another register.  So use libunwind to fetch the register
  354.            value for us, and create a constant value with the result.  */
  355.         if (descr->is_fpreg (uw_regnum))
  356.           {
  357.             ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
  358.             if (ret < 0)
  359.               return frame_unwind_got_constant (this_frame, regnum, 0);
  360.             val = frame_unwind_got_bytes (this_frame, regnum,
  361.                                           (gdb_byte *) &fpval);
  362.           }
  363.         else
  364.           {
  365.             ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
  366.             if (ret < 0)
  367.               return frame_unwind_got_constant (this_frame, regnum, 0);
  368.             val = frame_unwind_got_constant (this_frame, regnum, intval);
  369.           }
  370.         break;
  371.       }
  372.     }

  374.   return val;
  375. }

  377. /* The following is a glue routine to call the libunwind unwind table
  378.    search function to get unwind information for a specified ip address.  */
  379. int
  380. ‌libunwind_search_unwind_table (void *as, long ip, void *di,
  381.                                void *pi, int need_unwind_info, void *args)
  382. {
  383.   return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
  384.                                     di, pi, need_unwind_info, args);
  385. }

  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.                                   struct frame_info *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 i, ret;

  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.  */

  407.   descr = libunwind_descr (gdbarch);
  408.   acc = 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);

  415.   ret = unw_init_remote_p (&cursor, as, this_frame);

  417.   if (ret < 0)
  418.     {
  419.       unw_destroy_addr_space_p (as);
  420.       return 0;
  421.     }

  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;

  429.   return 0;
  430. }

  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, struct 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;


  452.   descr = libunwind_descr (gdbarch);
  453.   acc = 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);

  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.     }

  467.   uw_regnum = descr->gdb2uw (regnum);

  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.     }

  480.   unw_destroy_addr_space_p (as);

  482.   if (ret < 0)
  483.     return -1;

  485.   if (buf)
  486.     memcpy (buf, ptr, register_size (gdbarch, regnum));

  488.   return 0;
  489. }

  491. static int
  492. ‌libunwind_load (void)
  493. {
  494.   void *handle;
  495.   char *so_error = NULL;

  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.       fprintf_unfiltered (gdb_stderr, _("[GDB failed to load %s: %s]\n"),
  508.                           LIBUNWIND_SO, so_error);
  509. #ifdef LIBUNWIND_SO_7
  510.       fprintf_unfiltered (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;

  518.   /* Initialize pointers to the dynamic library functions we will use.  */

  520.   unw_get_reg_p = dlsym (handle, get_reg_name);
  521.   if (unw_get_reg_p == NULL)
  522.     return 0;

  524.   unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
  525.   if (unw_get_fpreg_p == NULL)
  526.     return 0;

  528.   unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
  529.   if (unw_get_saveloc_p == NULL)
  530.     return 0;

  532.   unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
  533.   if (unw_is_signal_frame_p == NULL)
  534.     return 0;

  536.   unw_step_p = dlsym (handle, step_name);
  537.   if (unw_step_p == NULL)
  538.     return 0;

  540.   unw_init_remote_p = dlsym (handle, init_remote_name);
  541.   if (unw_init_remote_p == NULL)
  542.     return 0;

  544.   unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
  545.   if (unw_create_addr_space_p == NULL)
  546.     return 0;

  548.   unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
  549.   if (unw_destroy_addr_space_p == NULL)
  550.     return 0;

  552.   unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
  553.   if (unw_search_unwind_table_p == NULL)
  554.     return 0;

  556.   unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
  557.   if (unw_find_dyn_list_p == NULL)
  558.     return 0;

  560.   return 1;
  561. }

  563. int
  564. ‌libunwind_is_initialized (void)
  565. {
  566.   return libunwind_initialized;
  567. }

  569. /* Provide a prototype to silence -Wmissing-prototypes.  */
  570. void _initialize_libunwind_frame (void);

  572. void
  573. ‌_initialize_libunwind_frame (void)
  574. {
  575.   libunwind_descr_handle
  576.     = gdbarch_data_register_post_init (libunwind_descr_init);

  578.   libunwind_initialized = libunwind_load ();
  579. }