gdb/frame-unwind.c

   1 /* Definitions for frame unwinder, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003-2021 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "frame-unwind.h"
  23 #include "dummy-frame.h"
  24 #include "inline-frame.h"
  25 #include "value.h"
  26 #include "regcache.h"
  27 #include "gdb_obstack.h"
  28 #include "target.h"
  29 #include "gdbarch.h"
  30 #include "dwarf2/frame-tailcall.h"
  31
  32 static struct gdbarch_data *frame_unwind_data;
  33
  34 struct frame_unwind_table_entry
  35 {
  36   const struct frame_unwind *unwinder;
  37   struct frame_unwind_table_entry *next;
  38 };
  39
  40 struct frame_unwind_table
  41 {
  42   struct frame_unwind_table_entry *list;
  43   /* The head of the OSABI part of the search list.  */
  44   struct frame_unwind_table_entry **osabi_head;
  45 };
  46
  47 /* A helper function to add an unwinder to a list.  LINK says where to
  48    install the new unwinder.  The new link is returned.  */
  49
  50 static struct frame_unwind_table_entry **
  51 add_unwinder (struct obstack *obstack, const struct frame_unwind *unwinder,
  52               struct frame_unwind_table_entry **link)
  53 {
  54   *link = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry);
  55   (*link)->unwinder = unwinder;
  56   return &(*link)->next;
  57 }
  58
  59 static void *
  60 frame_unwind_init (struct obstack *obstack)
  61 {
  62   struct frame_unwind_table *table
  63     = OBSTACK_ZALLOC (obstack, struct frame_unwind_table);
  64
  65   /* Start the table out with a few default sniffers.  OSABI code
  66      can't override this.  */
  67   struct frame_unwind_table_entry **link = &table->list;
  68
  69   link = add_unwinder (obstack, &dummy_frame_unwind, link);
  70   /* The DWARF tailcall sniffer must come before the inline sniffer.
  71      Otherwise, we can end up in a situation where a DWARF frame finds
  72      tailcall information, but then the inline sniffer claims a frame
  73      before the tailcall sniffer, resulting in confusion.  This is
  74      safe to do always because the tailcall sniffer can only ever be
  75      activated if the newer frame was created using the DWARF
  76      unwinder, and it also found tailcall information.  */
  77   link = add_unwinder (obstack, &dwarf2_tailcall_frame_unwind, link);
  78   link = add_unwinder (obstack, &inline_frame_unwind, link);
  79
  80   /* The insertion point for OSABI sniffers.  */
  81   table->osabi_head = link;
  82   return table;
  83 }
  84
  85 void
  86 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch,
  87                                 const struct frame_unwind *unwinder)
  88 {
  89   struct frame_unwind_table *table
  90     = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
  91   struct frame_unwind_table_entry *entry;
  92
  93   /* Insert the new entry at the start of the list.  */
  94   entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry);
  95   entry->unwinder = unwinder;
  96   entry->next = (*table->osabi_head);
  97   (*table->osabi_head) = entry;
  98 }
  99
 100 void
 101 frame_unwind_append_unwinder (struct gdbarch *gdbarch,
 102                               const struct frame_unwind *unwinder)
 103 {
 104   struct frame_unwind_table *table
 105     = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
 106   struct frame_unwind_table_entry **ip;
 107
 108   /* Find the end of the list and insert the new entry there.  */
 109   for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next);
 110   (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry);
 111   (*ip)->unwinder = unwinder;
 112 }
 113
 114 /* Call SNIFFER from UNWINDER.  If it succeeded set UNWINDER for
 115    THIS_FRAME and return 1.  Otherwise the function keeps THIS_FRAME
 116    unchanged and returns 0.  */
 117
 118 static int
 119 frame_unwind_try_unwinder (struct frame_info *this_frame, void **this_cache,
 120                           const struct frame_unwind *unwinder)
 121 {
 122   int res = 0;
 123
 124   unsigned int entry_generation = get_frame_cache_generation ();
 125
 126   frame_prepare_for_sniffer (this_frame, unwinder);
 127
 128   try
 129     {
 130       res = unwinder->sniffer (unwinder, this_frame, this_cache);
 131     }
 132   catch (const gdb_exception &ex)
 133     {
 134       /* Catch all exceptions, caused by either interrupt or error.
 135          Reset *THIS_CACHE, unless something reinitialized the frame
 136          cache meanwhile, in which case THIS_FRAME/THIS_CACHE are now
 137          dangling.  */
 138       if (get_frame_cache_generation () == entry_generation)
 139         {
 140           *this_cache = NULL;
 141           frame_cleanup_after_sniffer (this_frame);
 142         }
 143
 144       if (ex.error == NOT_AVAILABLE_ERROR)
 145         {
 146           /* This usually means that not even the PC is available,
 147              thus most unwinders aren't able to determine if they're
 148              the best fit.  Keep trying.  Fallback prologue unwinders
 149              should always accept the frame.  */
 150           return 0;
 151         }
 152       throw;
 153     }
 154
 155   if (res)
 156     return 1;
 157   else
 158     {
 159       /* Don't set *THIS_CACHE to NULL here, because sniffer has to do
 160          so.  */
 161       frame_cleanup_after_sniffer (this_frame);
 162       return 0;
 163     }
 164   gdb_assert_not_reached ("frame_unwind_try_unwinder");
 165 }
 166
 167 /* Iterate through sniffers for THIS_FRAME frame until one returns with an
 168    unwinder implementation.  THIS_FRAME->UNWIND must be NULL, it will get set
 169    by this function.  Possibly initialize THIS_CACHE.  */
 170
 171 void
 172 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache)
 173 {
 174   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 175   struct frame_unwind_table *table
 176     = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
 177   struct frame_unwind_table_entry *entry;
 178   const struct frame_unwind *unwinder_from_target;
 179
 180   unwinder_from_target = target_get_unwinder ();
 181   if (unwinder_from_target != NULL
 182       && frame_unwind_try_unwinder (this_frame, this_cache,
 183                                    unwinder_from_target))
 184     return;
 185
 186   unwinder_from_target = target_get_tailcall_unwinder ();
 187   if (unwinder_from_target != NULL
 188       && frame_unwind_try_unwinder (this_frame, this_cache,
 189                                    unwinder_from_target))
 190     return;
 191
 192   for (entry = table->list; entry != NULL; entry = entry->next)
 193     if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder))
 194       return;
 195
 196   internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed"));
 197 }
 198
 199 /* A default frame sniffer which always accepts the frame.  Used by
 200    fallback prologue unwinders.  */
 201
 202 int
 203 default_frame_sniffer (const struct frame_unwind *self,
 204                        struct frame_info *this_frame,
 205                        void **this_prologue_cache)
 206 {
 207   return 1;
 208 }
 209
 210 /* The default frame unwinder stop_reason callback.  */
 211
 212 enum unwind_stop_reason
 213 default_frame_unwind_stop_reason (struct frame_info *this_frame,
 214                                   void **this_cache)
 215 {
 216   struct frame_id this_id = get_frame_id (this_frame);
 217
 218   if (frame_id_eq (this_id, outer_frame_id))
 219     return UNWIND_OUTERMOST;
 220   else
 221     return UNWIND_NO_REASON;
 222 }
 223
 224 /* See frame-unwind.h.  */
 225
 226 CORE_ADDR
 227 default_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 228 {
 229   int pc_regnum = gdbarch_pc_regnum (gdbarch);
 230   CORE_ADDR pc = frame_unwind_register_unsigned (next_frame, pc_regnum);
 231   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 232   return pc;
 233 }
 234
 235 /* See frame-unwind.h.  */
 236
 237 CORE_ADDR
 238 default_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 239 {
 240   int sp_regnum = gdbarch_sp_regnum (gdbarch);
 241   return frame_unwind_register_unsigned (next_frame, sp_regnum);
 242 }
 243
 244 /* Helper functions for value-based register unwinding.  These return
 245    a (possibly lazy) value of the appropriate type.  */
 246
 247 /* Return a value which indicates that FRAME did not save REGNUM.  */
 248
 249 struct value *
 250 frame_unwind_got_optimized (struct frame_info *frame, int regnum)
 251 {
 252   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 253   struct type *type = register_type (gdbarch, regnum);
 254
 255   return allocate_optimized_out_value (type);
 256 }
 257
 258 /* Return a value which indicates that FRAME copied REGNUM into
 259    register NEW_REGNUM.  */
 260
 261 struct value *
 262 frame_unwind_got_register (struct frame_info *frame,
 263                            int regnum, int new_regnum)
 264 {
 265   return value_of_register_lazy (frame, new_regnum);
 266 }
 267
 268 /* Return a value which indicates that FRAME saved REGNUM in memory at
 269    ADDR.  */
 270
 271 struct value *
 272 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr)
 273 {
 274   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 275   struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr);
 276
 277   set_value_stack (v, 1);
 278   return v;
 279 }
 280
 281 /* Return a value which indicates that FRAME's saved version of
 282    REGNUM has a known constant (computed) value of VAL.  */
 283
 284 struct value *
 285 frame_unwind_got_constant (struct frame_info *frame, int regnum,
 286                            ULONGEST val)
 287 {
 288   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 289   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 290   struct value *reg_val;
 291
 292   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 293   store_unsigned_integer (value_contents_writeable (reg_val),
 294                           register_size (gdbarch, regnum), byte_order, val);
 295   return reg_val;
 296 }
 297
 298 struct value *
 299 frame_unwind_got_bytes (struct frame_info *frame, int regnum, const gdb_byte *buf)
 300 {
 301   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 302   struct value *reg_val;
 303
 304   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 305   memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum));
 306   return reg_val;
 307 }
 308
 309 /* Return a value which indicates that FRAME's saved version of REGNUM
 310    has a known constant (computed) value of ADDR.  Convert the
 311    CORE_ADDR to a target address if necessary.  */
 312
 313 struct value *
 314 frame_unwind_got_address (struct frame_info *frame, int regnum,
 315                           CORE_ADDR addr)
 316 {
 317   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 318   struct value *reg_val;
 319
 320   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 321   pack_long (value_contents_writeable (reg_val),
 322              register_type (gdbarch, regnum), addr);
 323   return reg_val;
 324 }
 325
 326 void _initialize_frame_unwind ();
 327 void
 328 _initialize_frame_unwind ()
 329 {
 330   frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init);
 331 }