gdb/frame-unwind.c

   1 /* Definitions for frame unwinder, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003-2022 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 "gdbsupport/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_SCOPED_DEBUG_ENTER_EXIT;
 182   frame_debug_printf ("this_frame=%d", frame_relative_level (this_frame));
 183
 184   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 185   struct frame_unwind_table *table
 186     = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
 187   struct frame_unwind_table_entry *entry;
 188   const struct frame_unwind *unwinder_from_target;
 189
 190   unwinder_from_target = target_get_unwinder ();
 191   if (unwinder_from_target != NULL
 192       && frame_unwind_try_unwinder (this_frame, this_cache,
 193                                    unwinder_from_target))
 194     return;
 195
 196   unwinder_from_target = target_get_tailcall_unwinder ();
 197   if (unwinder_from_target != NULL
 198       && frame_unwind_try_unwinder (this_frame, this_cache,
 199                                    unwinder_from_target))
 200     return;
 201
 202   for (entry = table->list; entry != NULL; entry = entry->next)
 203     if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder))
 204       return;
 205
 206   internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed"));
 207 }
 208
 209 /* A default frame sniffer which always accepts the frame.  Used by
 210    fallback prologue unwinders.  */
 211
 212 int
 213 default_frame_sniffer (const struct frame_unwind *self,
 214                        struct frame_info *this_frame,
 215                        void **this_prologue_cache)
 216 {
 217   return 1;
 218 }
 219
 220 /* The default frame unwinder stop_reason callback.  */
 221
 222 enum unwind_stop_reason
 223 default_frame_unwind_stop_reason (struct frame_info *this_frame,
 224                                   void **this_cache)
 225 {
 226   struct frame_id this_id = get_frame_id (this_frame);
 227
 228   if (frame_id_eq (this_id, outer_frame_id))
 229     return UNWIND_OUTERMOST;
 230   else
 231     return UNWIND_NO_REASON;
 232 }
 233
 234 /* See frame-unwind.h.  */
 235
 236 CORE_ADDR
 237 default_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 238 {
 239   int pc_regnum = gdbarch_pc_regnum (gdbarch);
 240   CORE_ADDR pc = frame_unwind_register_unsigned (next_frame, pc_regnum);
 241   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 242   return pc;
 243 }
 244
 245 /* See frame-unwind.h.  */
 246
 247 CORE_ADDR
 248 default_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 249 {
 250   int sp_regnum = gdbarch_sp_regnum (gdbarch);
 251   return frame_unwind_register_unsigned (next_frame, sp_regnum);
 252 }
 253
 254 /* Helper functions for value-based register unwinding.  These return
 255    a (possibly lazy) value of the appropriate type.  */
 256
 257 /* Return a value which indicates that FRAME did not save REGNUM.  */
 258
 259 struct value *
 260 frame_unwind_got_optimized (struct frame_info *frame, int regnum)
 261 {
 262   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 263   struct type *type = register_type (gdbarch, regnum);
 264
 265   return allocate_optimized_out_value (type);
 266 }
 267
 268 /* Return a value which indicates that FRAME copied REGNUM into
 269    register NEW_REGNUM.  */
 270
 271 struct value *
 272 frame_unwind_got_register (struct frame_info *frame,
 273                            int regnum, int new_regnum)
 274 {
 275   return value_of_register_lazy (frame, new_regnum);
 276 }
 277
 278 /* Return a value which indicates that FRAME saved REGNUM in memory at
 279    ADDR.  */
 280
 281 struct value *
 282 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr)
 283 {
 284   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 285   struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr);
 286
 287   set_value_stack (v, 1);
 288   return v;
 289 }
 290
 291 /* Return a value which indicates that FRAME's saved version of
 292    REGNUM has a known constant (computed) value of VAL.  */
 293
 294 struct value *
 295 frame_unwind_got_constant (struct frame_info *frame, int regnum,
 296                            ULONGEST val)
 297 {
 298   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 299   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 300   struct value *reg_val;
 301
 302   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 303   store_unsigned_integer (value_contents_writeable (reg_val).data (),
 304                           register_size (gdbarch, regnum), byte_order, val);
 305   return reg_val;
 306 }
 307
 308 struct value *
 309 frame_unwind_got_bytes (struct frame_info *frame, int regnum, const gdb_byte *buf)
 310 {
 311   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 312   struct value *reg_val;
 313
 314   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 315   memcpy (value_contents_raw (reg_val).data (), buf,
 316           register_size (gdbarch, regnum));
 317   return reg_val;
 318 }
 319
 320 /* Return a value which indicates that FRAME's saved version of REGNUM
 321    has a known constant (computed) value of ADDR.  Convert the
 322    CORE_ADDR to a target address if necessary.  */
 323
 324 struct value *
 325 frame_unwind_got_address (struct frame_info *frame, int regnum,
 326                           CORE_ADDR addr)
 327 {
 328   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 329   struct value *reg_val;
 330
 331   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 332   pack_long (value_contents_writeable (reg_val).data (),
 333              register_type (gdbarch, regnum), addr);
 334   return reg_val;
 335 }
 336
 337 void _initialize_frame_unwind ();
 338 void
 339 _initialize_frame_unwind ()
 340 {
 341   frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init);
 342 }