1 /* Definitions for frame unwinder, for GDB, the GNU debugger. 2 3 Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010 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 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, struct frame_unwind_table_entry); 58 table->list->next->unwinder = inline_frame_unwind; 59 /* The insertion point for OSABI sniffers. */ 60 table->osabi_head = &table->list->next->next; 61 return table; 62 } 63 64 void 65 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, 66 const struct frame_unwind *unwinder) 67 { 68 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 69 struct frame_unwind_table_entry *entry; 70 71 /* Insert the new entry at the start of the list. */ 72 entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 73 entry->unwinder = unwinder; 74 entry->next = (*table->osabi_head); 75 (*table->osabi_head) = entry; 76 } 77 78 void 79 frame_unwind_append_unwinder (struct gdbarch *gdbarch, 80 const struct frame_unwind *unwinder) 81 { 82 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 83 struct frame_unwind_table_entry **ip; 84 85 /* Find the end of the list and insert the new entry there. */ 86 for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); 87 (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 88 (*ip)->unwinder = unwinder; 89 } 90 91 const struct frame_unwind * 92 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache) 93 { 94 struct gdbarch *gdbarch = get_frame_arch (this_frame); 95 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 96 struct frame_unwind_table_entry *entry; 97 98 for (entry = table->list; entry != NULL; entry = entry->next) 99 { 100 struct cleanup *old_cleanup; 101 102 old_cleanup = frame_prepare_for_sniffer (this_frame, entry->unwinder); 103 if (entry->unwinder->sniffer (entry->unwinder, this_frame, 104 this_cache)) 105 { 106 discard_cleanups (old_cleanup); 107 return entry->unwinder; 108 } 109 do_cleanups (old_cleanup); 110 } 111 internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); 112 } 113 114 /* A default frame sniffer which always accepts the frame. Used by 115 fallback prologue unwinders. */ 116 117 int 118 default_frame_sniffer (const struct frame_unwind *self, 119 struct frame_info *this_frame, 120 void **this_prologue_cache) 121 { 122 return 1; 123 } 124 125 /* Helper functions for value-based register unwinding. These return 126 a (possibly lazy) value of the appropriate type. */ 127 128 /* Return a value which indicates that FRAME did not save REGNUM. */ 129 130 struct value * 131 frame_unwind_got_optimized (struct frame_info *frame, int regnum) 132 { 133 struct gdbarch *gdbarch = frame_unwind_arch (frame); 134 struct value *reg_val; 135 136 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 137 set_value_optimized_out (reg_val, 1); 138 return reg_val; 139 } 140 141 /* Return a value which indicates that FRAME copied REGNUM into 142 register NEW_REGNUM. */ 143 144 struct value * 145 frame_unwind_got_register (struct frame_info *frame, int regnum, int new_regnum) 146 { 147 return value_of_register_lazy (frame, new_regnum); 148 } 149 150 /* Return a value which indicates that FRAME saved REGNUM in memory at 151 ADDR. */ 152 153 struct value * 154 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) 155 { 156 struct gdbarch *gdbarch = frame_unwind_arch (frame); 157 struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); 158 159 set_value_stack (v, 1); 160 return v; 161 } 162 163 /* Return a value which indicates that FRAME's saved version of 164 REGNUM has a known constant (computed) value of VAL. */ 165 166 struct value * 167 frame_unwind_got_constant (struct frame_info *frame, int regnum, 168 ULONGEST val) 169 { 170 struct gdbarch *gdbarch = frame_unwind_arch (frame); 171 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 172 struct value *reg_val; 173 174 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 175 store_unsigned_integer (value_contents_writeable (reg_val), 176 register_size (gdbarch, regnum), byte_order, val); 177 return reg_val; 178 } 179 180 struct value * 181 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) 182 { 183 struct gdbarch *gdbarch = frame_unwind_arch (frame); 184 struct value *reg_val; 185 186 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 187 memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); 188 return reg_val; 189 } 190 191 /* Return a value which indicates that FRAME's saved version of REGNUM 192 has a known constant (computed) value of ADDR. Convert the 193 CORE_ADDR to a target address if necessary. */ 194 195 struct value * 196 frame_unwind_got_address (struct frame_info *frame, int regnum, 197 CORE_ADDR addr) 198 { 199 struct gdbarch *gdbarch = frame_unwind_arch (frame); 200 struct value *reg_val; 201 202 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 203 pack_long (value_contents_writeable (reg_val), 204 register_type (gdbarch, regnum), addr); 205 return reg_val; 206 } 207 208 extern initialize_file_ftype _initialize_frame_unwind; /* -Wmissing-prototypes */ 209 210 void 211 _initialize_frame_unwind (void) 212 { 213 frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init); 214 } 215