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