gdb/frame-unwind.c

   1 /* Definitions for frame unwinder, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003-2020 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   struct value *val;
 255
 256   /* Return an lval_register value, so that we print it as
 257      "<not saved>".  */
 258   val = allocate_value_lazy (type);
 259   set_value_lazy (val, 0);
 260   mark_value_bytes_optimized_out (val, 0, TYPE_LENGTH (type));
 261   VALUE_LVAL (val) = lval_register;
 262   VALUE_REGNUM (val) = regnum;
 263   VALUE_NEXT_FRAME_ID (val)
 264     = get_frame_id (get_next_frame_sentinel_okay (frame));
 265   return val;
 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),
 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, 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), buf, register_size (gdbarch, regnum));
 316   return reg_val;
 317 }
 318
 319 /* Return a value which indicates that FRAME's saved version of REGNUM
 320    has a known constant (computed) value of ADDR.  Convert the
 321    CORE_ADDR to a target address if necessary.  */
 322
 323 struct value *
 324 frame_unwind_got_address (struct frame_info *frame, int regnum,
 325                           CORE_ADDR addr)
 326 {
 327   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 328   struct value *reg_val;
 329
 330   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 331   pack_long (value_contents_writeable (reg_val),
 332              register_type (gdbarch, regnum), addr);
 333   return reg_val;
 334 }
 335
 336 void _initialize_frame_unwind ();
 337 void
 338 _initialize_frame_unwind ()
 339 {
 340   frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init);
 341 }