contrib/gdb-7/gdb/frame-unwind.c

   1 /* Definitions for frame unwinder, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "dummy-frame.h"
  25 #include "inline-frame.h"
  26 #include "value.h"
  27 #include "regcache.h"
  28 #include "exceptions.h"
  29 #include "gdb_assert.h"
  30 #include "gdb_obstack.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 static void *
  48 frame_unwind_init (struct obstack *obstack)
  49 {
  50   struct frame_unwind_table *table
  51     = OBSTACK_ZALLOC (obstack, struct frame_unwind_table);
  52
  53   /* Start the table out with a few default sniffers.  OSABI code
  54      can't override this.  */
  55   table->list = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry);
  56   table->list->unwinder = &dummy_frame_unwind;
  57   table->list->next = OBSTACK_ZALLOC (obstack,
  58                                       struct frame_unwind_table_entry);
  59   table->list->next->unwinder = &inline_frame_unwind;
  60   /* The insertion point for OSABI sniffers.  */
  61   table->osabi_head = &table->list->next->next;
  62   return table;
  63 }
  64
  65 void
  66 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch,
  67                                 const struct frame_unwind *unwinder)
  68 {
  69   struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
  70   struct frame_unwind_table_entry *entry;
  71
  72   /* Insert the new entry at the start of the list.  */
  73   entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry);
  74   entry->unwinder = unwinder;
  75   entry->next = (*table->osabi_head);
  76   (*table->osabi_head) = entry;
  77 }
  78
  79 void
  80 frame_unwind_append_unwinder (struct gdbarch *gdbarch,
  81                               const struct frame_unwind *unwinder)
  82 {
  83   struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
  84   struct frame_unwind_table_entry **ip;
  85
  86   /* Find the end of the list and insert the new entry there.  */
  87   for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next);
  88   (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry);
  89   (*ip)->unwinder = unwinder;
  90 }
  91
  92 /* Iterate through sniffers for THIS_FRAME frame until one returns with an
  93    unwinder implementation.  THIS_FRAME->UNWIND must be NULL, it will get set
  94    by this function.  Possibly initialize THIS_CACHE.  */
  95
  96 void
  97 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache)
  98 {
  99   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 100   struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
 101   struct frame_unwind_table_entry *entry;
 102
 103   for (entry = table->list; entry != NULL; entry = entry->next)
 104     {
 105       struct cleanup *old_cleanup;
 106       volatile struct gdb_exception ex;
 107       int res = 0;
 108
 109       old_cleanup = frame_prepare_for_sniffer (this_frame, entry->unwinder);
 110
 111       TRY_CATCH (ex, RETURN_MASK_ERROR)
 112         {
 113           res = entry->unwinder->sniffer (entry->unwinder, this_frame,
 114                                           this_cache);
 115         }
 116       if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
 117         {
 118           /* This usually means that not even the PC is available,
 119              thus most unwinders aren't able to determine if they're
 120              the best fit.  Keep trying.  Fallback prologue unwinders
 121              should always accept the frame.  */
 122         }
 123       else if (ex.reason < 0)
 124         throw_exception (ex);
 125       else if (res)
 126         {
 127           discard_cleanups (old_cleanup);
 128           return;
 129         }
 130
 131       do_cleanups (old_cleanup);
 132     }
 133   internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed"));
 134 }
 135
 136 /* A default frame sniffer which always accepts the frame.  Used by
 137    fallback prologue unwinders.  */
 138
 139 int
 140 default_frame_sniffer (const struct frame_unwind *self,
 141                        struct frame_info *this_frame,
 142                        void **this_prologue_cache)
 143 {
 144   return 1;
 145 }
 146
 147 /* A default frame unwinder stop_reason callback that always claims
 148    the frame is unwindable.  */
 149
 150 enum unwind_stop_reason
 151 default_frame_unwind_stop_reason (struct frame_info *this_frame,
 152                                   void **this_cache)
 153 {
 154   return UNWIND_NO_REASON;
 155 }
 156
 157 /* Helper functions for value-based register unwinding.  These return
 158    a (possibly lazy) value of the appropriate type.  */
 159
 160 /* Return a value which indicates that FRAME did not save REGNUM.  */
 161
 162 struct value *
 163 frame_unwind_got_optimized (struct frame_info *frame, int regnum)
 164 {
 165   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 166   struct value *reg_val;
 167
 168   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 169   set_value_optimized_out (reg_val, 1);
 170   return reg_val;
 171 }
 172
 173 /* Return a value which indicates that FRAME copied REGNUM into
 174    register NEW_REGNUM.  */
 175
 176 struct value *
 177 frame_unwind_got_register (struct frame_info *frame,
 178                            int regnum, int new_regnum)
 179 {
 180   return value_of_register_lazy (frame, new_regnum);
 181 }
 182
 183 /* Return a value which indicates that FRAME saved REGNUM in memory at
 184    ADDR.  */
 185
 186 struct value *
 187 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr)
 188 {
 189   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 190   struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr);
 191
 192   set_value_stack (v, 1);
 193   return v;
 194 }
 195
 196 /* Return a value which indicates that FRAME's saved version of
 197    REGNUM has a known constant (computed) value of VAL.  */
 198
 199 struct value *
 200 frame_unwind_got_constant (struct frame_info *frame, int regnum,
 201                            ULONGEST val)
 202 {
 203   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 204   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 205   struct value *reg_val;
 206
 207   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 208   store_unsigned_integer (value_contents_writeable (reg_val),
 209                           register_size (gdbarch, regnum), byte_order, val);
 210   return reg_val;
 211 }
 212
 213 struct value *
 214 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf)
 215 {
 216   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 217   struct value *reg_val;
 218
 219   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 220   memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum));
 221   return reg_val;
 222 }
 223
 224 /* Return a value which indicates that FRAME's saved version of REGNUM
 225    has a known constant (computed) value of ADDR.  Convert the
 226    CORE_ADDR to a target address if necessary.  */
 227
 228 struct value *
 229 frame_unwind_got_address (struct frame_info *frame, int regnum,
 230                           CORE_ADDR addr)
 231 {
 232   struct gdbarch *gdbarch = frame_unwind_arch (frame);
 233   struct value *reg_val;
 234
 235   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 236   pack_long (value_contents_writeable (reg_val),
 237              register_type (gdbarch, regnum), addr);
 238   return reg_val;
 239 }
 240
 241 /* -Wmissing-prototypes */
 242 extern initialize_file_ftype _initialize_frame_unwind;
 243
 244 void
 245 _initialize_frame_unwind (void)
 246 {
 247   frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init);
 248 }