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