1 /* Definitions for frame unwinder, for GDB, the GNU debugger. 2 3 Copyright (C) 2003-2015 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 30 static struct gdbarch_data *frame_unwind_data; 31 32 struct frame_unwind_table_entry 33 { 34 const struct frame_unwind *unwinder; 35 struct frame_unwind_table_entry *next; 36 }; 37 38 struct frame_unwind_table 39 { 40 struct frame_unwind_table_entry *list; 41 /* The head of the OSABI part of the search list. */ 42 struct frame_unwind_table_entry **osabi_head; 43 }; 44 45 static void * 46 frame_unwind_init (struct obstack *obstack) 47 { 48 struct frame_unwind_table *table 49 = OBSTACK_ZALLOC (obstack, struct frame_unwind_table); 50 51 /* Start the table out with a few default sniffers. OSABI code 52 can't override this. */ 53 table->list = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); 54 table->list->unwinder = &dummy_frame_unwind; 55 table->list->next = OBSTACK_ZALLOC (obstack, 56 struct frame_unwind_table_entry); 57 table->list->next->unwinder = &inline_frame_unwind; 58 /* The insertion point for OSABI sniffers. */ 59 table->osabi_head = &table->list->next->next; 60 return table; 61 } 62 63 void 64 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, 65 const struct frame_unwind *unwinder) 66 { 67 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 68 struct frame_unwind_table_entry *entry; 69 70 /* Insert the new entry at the start of the list. */ 71 entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 72 entry->unwinder = unwinder; 73 entry->next = (*table->osabi_head); 74 (*table->osabi_head) = entry; 75 } 76 77 void 78 frame_unwind_append_unwinder (struct gdbarch *gdbarch, 79 const struct frame_unwind *unwinder) 80 { 81 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 82 struct frame_unwind_table_entry **ip; 83 84 /* Find the end of the list and insert the new entry there. */ 85 for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); 86 (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 87 (*ip)->unwinder = unwinder; 88 } 89 90 /* Call SNIFFER from UNWINDER. If it succeeded set UNWINDER for 91 THIS_FRAME and return 1. Otherwise the function keeps THIS_FRAME 92 unchanged and returns 0. */ 93 94 static int 95 frame_unwind_try_unwinder (struct frame_info *this_frame, void **this_cache, 96 const struct frame_unwind *unwinder) 97 { 98 struct cleanup *old_cleanup; 99 int res = 0; 100 101 old_cleanup = frame_prepare_for_sniffer (this_frame, unwinder); 102 103 TRY 104 { 105 res = unwinder->sniffer (unwinder, this_frame, this_cache); 106 } 107 CATCH (ex, RETURN_MASK_ERROR) 108 { 109 if (ex.error == NOT_AVAILABLE_ERROR) 110 { 111 /* This usually means that not even the PC is available, 112 thus most unwinders aren't able to determine if they're 113 the best fit. Keep trying. Fallback prologue unwinders 114 should always accept the frame. */ 115 do_cleanups (old_cleanup); 116 return 0; 117 } 118 throw_exception (ex); 119 } 120 END_CATCH 121 122 if (res) 123 { 124 discard_cleanups (old_cleanup); 125 return 1; 126 } 127 else 128 { 129 do_cleanups (old_cleanup); 130 return 0; 131 } 132 gdb_assert_not_reached ("frame_unwind_try_unwinder"); 133 } 134 135 /* Iterate through sniffers for THIS_FRAME frame until one returns with an 136 unwinder implementation. THIS_FRAME->UNWIND must be NULL, it will get set 137 by this function. Possibly initialize THIS_CACHE. */ 138 139 void 140 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache) 141 { 142 struct gdbarch *gdbarch = get_frame_arch (this_frame); 143 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 144 struct frame_unwind_table_entry *entry; 145 const struct frame_unwind *unwinder_from_target; 146 147 unwinder_from_target = target_get_unwinder (); 148 if (unwinder_from_target != NULL 149 && frame_unwind_try_unwinder (this_frame, this_cache, 150 unwinder_from_target)) 151 return; 152 153 unwinder_from_target = target_get_tailcall_unwinder (); 154 if (unwinder_from_target != NULL 155 && frame_unwind_try_unwinder (this_frame, this_cache, 156 unwinder_from_target)) 157 return; 158 159 for (entry = table->list; entry != NULL; entry = entry->next) 160 if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder)) 161 return; 162 163 internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); 164 } 165 166 /* A default frame sniffer which always accepts the frame. Used by 167 fallback prologue unwinders. */ 168 169 int 170 default_frame_sniffer (const struct frame_unwind *self, 171 struct frame_info *this_frame, 172 void **this_prologue_cache) 173 { 174 return 1; 175 } 176 177 /* The default frame unwinder stop_reason callback. */ 178 179 enum unwind_stop_reason 180 default_frame_unwind_stop_reason (struct frame_info *this_frame, 181 void **this_cache) 182 { 183 struct frame_id this_id = get_frame_id (this_frame); 184 185 if (frame_id_eq (this_id, outer_frame_id)) 186 return UNWIND_OUTERMOST; 187 else 188 return UNWIND_NO_REASON; 189 } 190 191 /* Helper functions for value-based register unwinding. These return 192 a (possibly lazy) value of the appropriate type. */ 193 194 /* Return a value which indicates that FRAME did not save REGNUM. */ 195 196 struct value * 197 frame_unwind_got_optimized (struct frame_info *frame, int regnum) 198 { 199 struct gdbarch *gdbarch = frame_unwind_arch (frame); 200 struct type *type = register_type (gdbarch, regnum); 201 struct value *val; 202 203 /* Return an lval_register value, so that we print it as 204 "<not saved>". */ 205 val = allocate_value_lazy (type); 206 set_value_lazy (val, 0); 207 mark_value_bytes_optimized_out (val, 0, TYPE_LENGTH (type)); 208 VALUE_LVAL (val) = lval_register; 209 VALUE_REGNUM (val) = regnum; 210 VALUE_FRAME_ID (val) = get_frame_id (frame); 211 return val; 212 } 213 214 /* Return a value which indicates that FRAME copied REGNUM into 215 register NEW_REGNUM. */ 216 217 struct value * 218 frame_unwind_got_register (struct frame_info *frame, 219 int regnum, int new_regnum) 220 { 221 return value_of_register_lazy (frame, new_regnum); 222 } 223 224 /* Return a value which indicates that FRAME saved REGNUM in memory at 225 ADDR. */ 226 227 struct value * 228 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) 229 { 230 struct gdbarch *gdbarch = frame_unwind_arch (frame); 231 struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); 232 233 set_value_stack (v, 1); 234 return v; 235 } 236 237 /* Return a value which indicates that FRAME's saved version of 238 REGNUM has a known constant (computed) value of VAL. */ 239 240 struct value * 241 frame_unwind_got_constant (struct frame_info *frame, int regnum, 242 ULONGEST val) 243 { 244 struct gdbarch *gdbarch = frame_unwind_arch (frame); 245 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 246 struct value *reg_val; 247 248 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 249 store_unsigned_integer (value_contents_writeable (reg_val), 250 register_size (gdbarch, regnum), byte_order, val); 251 return reg_val; 252 } 253 254 struct value * 255 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) 256 { 257 struct gdbarch *gdbarch = frame_unwind_arch (frame); 258 struct value *reg_val; 259 260 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 261 memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); 262 return reg_val; 263 } 264 265 /* Return a value which indicates that FRAME's saved version of REGNUM 266 has a known constant (computed) value of ADDR. Convert the 267 CORE_ADDR to a target address if necessary. */ 268 269 struct value * 270 frame_unwind_got_address (struct frame_info *frame, int regnum, 271 CORE_ADDR addr) 272 { 273 struct gdbarch *gdbarch = frame_unwind_arch (frame); 274 struct value *reg_val; 275 276 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 277 pack_long (value_contents_writeable (reg_val), 278 register_type (gdbarch, regnum), addr); 279 return reg_val; 280 } 281 282 /* -Wmissing-prototypes */ 283 extern initialize_file_ftype _initialize_frame_unwind; 284 285 void 286 _initialize_frame_unwind (void) 287 { 288 frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init); 289 } 290