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       frame_debug_printf ("trying unwinder \"%s\"", unwinder->name);
 131       res = unwinder->sniffer (unwinder, this_frame, this_cache);
 132     }
 133   catch (const gdb_exception &ex)
 134     {
 135       frame_debug_printf ("caught exception: %s", ex.message->c_str ());
 136
 137       /* Catch all exceptions, caused by either interrupt or error.
 138          Reset *THIS_CACHE, unless something reinitialized the frame
 139          cache meanwhile, in which case THIS_FRAME/THIS_CACHE are now
 140          dangling.  */
 141       if (get_frame_cache_generation () == entry_generation)
 142         {
 143           *this_cache = NULL;
 144           frame_cleanup_after_sniffer (this_frame);
 145         }
 146
 147       if (ex.error == NOT_AVAILABLE_ERROR)
 148         {
 149           /* This usually means that not even the PC is available,
 150              thus most unwinders aren't able to determine if they're
 151              the best fit.  Keep trying.  Fallback prologue unwinders
 152              should always accept the frame.  */
 153           return 0;
 154         }
 155       throw;
 156     }
 157
 158   if (res)
 159     {
 160       frame_debug_printf ("yes");
 161       return 1;
 162     }
 163   else
 164     {
 165       frame_debug_printf ("no");
 166       /* Don't set *THIS_CACHE to NULL here, because sniffer has to do
 167          so.  */
 168       frame_cleanup_after_sniffer (this_frame);
 169       return 0;
 170     }
 171   gdb_assert_not_reached ("frame_unwind_try_unwinder");
 172 }
 173
 174 /* Iterate through sniffers for THIS_FRAME frame until one returns with an
 175    unwinder implementation.  THIS_FRAME->UNWIND must be NULL, it will get set
 176    by this function.  Possibly initialize THIS_CACHE.  */
 177
 178 void
 179 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache)
 180 {
 181   frame_debug_printf ("this_frame=%d", frame_relative_level (this_frame));
 182
 183   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 184   struct frame_unwind_table *table
 185     = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
 186   struct frame_unwind_table_entry *entry;
 187   const struct frame_unwind *unwinder_from_target;
 188
 189   unwinder_from_target = target_get_unwinder ();
 190   if (unwinder_from_target != NULL
 191       && frame_unwind_try_unwinder (this_frame, this_cache,
 192                                    unwinder_from_target))
 193     return;
 194
 195   unwinder_from_target = target_get_tailcall_unwinder ();
 196   if (unwinder_from_target != NULL
 197       && frame_unwind_try_unwinder (this_frame, this_cache,
 198                                    unwinder_from_target))
 199     return;
 200
 201   for (entry = table->list; entry != NULL; entry = entry->next)
 202     if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder))
 203       return;
 204
 205   internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed"));
 206 }
 207
 208 /* A default frame sniffer which always accepts the frame.  Used by
 209    fallback prologue unwinders.  */
 210
 211 int
 212 default_frame_sniffer (const struct frame_unwind *self,
 213                        struct frame_info *this_frame,
 214                        void **this_prologue_cache)
 215 {
 216   return 1;
 217 }
 218
 219 /* The default frame unwinder stop_reason callback.  */
 220
 221 enum unwind_stop_reason
 222 default_frame_unwind_stop_reason (struct frame_info *this_frame,
 223                                   void **this_cache)
 224 {
 225   struct frame_id this_id = get_frame_id (this_frame);
 226
 227   if (frame_id_eq (this_id, outer_frame_id))
 228     return UNWIND_OUTERMOST;
 229   else
 230     return UNWIND_NO_REASON;
 231 }
 232
 233 /* See frame-unwind.h.  */
 234
 235 CORE_ADDR
 236 default_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 237 {
 238   int pc_regnum = gdbarch_pc_regnum (gdbarch);
 239   CORE_ADDR pc = frame_unwind_register_unsigned (next_frame, pc_regnum);
 240   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 241   return pc;
 242 }
 243
 244 /* See frame-unwind.h.  */
 245
 246 CORE_ADDR
 247 default_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 248 {
 249   int sp_regnum = gdbarch_sp_regnum (gdbarch);
 250   return frame_unwind_register_unsigned (next_frame, sp_regnum);
 251 }
 252
 253 /* Helper functions for value-based register unwinding.  These return
 254    a (possibly lazy) value of the appropriate type.  */
 255
 256 /* Return a value which indicates that FRAME did not save REGNUM.  */
 257
 258 struct value *
 259 frame_unwind_got_optimized (struct frame_info *frame, int regnum)
 260 {
 261   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 262   struct type *type = register_type (gdbarch, regnum);
 263
 264   return allocate_optimized_out_value (type);
 265 }
 266
 267 /* Return a value which indicates that FRAME copied REGNUM into
 268    register NEW_REGNUM.  */
 269
 270 struct value *
 271 frame_unwind_got_register (struct frame_info *frame,
 272                            int regnum, int new_regnum)
 273 {
 274   return value_of_register_lazy (frame, new_regnum);
 275 }
 276
 277 /* Return a value which indicates that FRAME saved REGNUM in memory at
 278    ADDR.  */
 279
 280 struct value *
 281 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr)
 282 {
 283   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 284   struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr);
 285
 286   set_value_stack (v, 1);
 287   return v;
 288 }
 289
 290 /* Return a value which indicates that FRAME's saved version of
 291    REGNUM has a known constant (computed) value of VAL.  */
 292
 293 struct value *
 294 frame_unwind_got_constant (struct frame_info *frame, int regnum,
 295                            ULONGEST val)
 296 {
 297   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 298   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 299   struct value *reg_val;
 300
 301   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 302   store_unsigned_integer (value_contents_writeable (reg_val),
 303                           register_size (gdbarch, regnum), byte_order, val);
 304   return reg_val;
 305 }
 306
 307 struct value *
 308 frame_unwind_got_bytes (struct frame_info *frame, int regnum, const gdb_byte *buf)
 309 {
 310   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 311   struct value *reg_val;
 312
 313   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 314   memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum));
 315   return reg_val;
 316 }
 317
 318 /* Return a value which indicates that FRAME's saved version of REGNUM
 319    has a known constant (computed) value of ADDR.  Convert the
 320    CORE_ADDR to a target address if necessary.  */
 321
 322 struct value *
 323 frame_unwind_got_address (struct frame_info *frame, int regnum,
 324                           CORE_ADDR addr)
 325 {
 326   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 327   struct value *reg_val;
 328
 329   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 330   pack_long (value_contents_writeable (reg_val),
 331              register_type (gdbarch, regnum), addr);
 332   return reg_val;
 333 }
 334
 335 void _initialize_frame_unwind ();
 336 void
 337 _initialize_frame_unwind ()
 338 {
 339   frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init);
 340 }