1 /* Definitions for frame unwinder, for GDB, the GNU debugger. 2 3 Copyright (C) 2003-2017 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_NEXT_FRAME_ID (val) 214 = get_frame_id (get_next_frame_sentinel_okay (frame)); 215 return val; 216 } 217 218 /* Return a value which indicates that FRAME copied REGNUM into 219 register NEW_REGNUM. */ 220 221 struct value * 222 frame_unwind_got_register (struct frame_info *frame, 223 int regnum, int new_regnum) 224 { 225 return value_of_register_lazy (frame, new_regnum); 226 } 227 228 /* Return a value which indicates that FRAME saved REGNUM in memory at 229 ADDR. */ 230 231 struct value * 232 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) 233 { 234 struct gdbarch *gdbarch = frame_unwind_arch (frame); 235 struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); 236 237 set_value_stack (v, 1); 238 return v; 239 } 240 241 /* Return a value which indicates that FRAME's saved version of 242 REGNUM has a known constant (computed) value of VAL. */ 243 244 struct value * 245 frame_unwind_got_constant (struct frame_info *frame, int regnum, 246 ULONGEST val) 247 { 248 struct gdbarch *gdbarch = frame_unwind_arch (frame); 249 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 250 struct value *reg_val; 251 252 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 253 store_unsigned_integer (value_contents_writeable (reg_val), 254 register_size (gdbarch, regnum), byte_order, val); 255 return reg_val; 256 } 257 258 struct value * 259 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) 260 { 261 struct gdbarch *gdbarch = frame_unwind_arch (frame); 262 struct value *reg_val; 263 264 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 265 memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); 266 return reg_val; 267 } 268 269 /* Return a value which indicates that FRAME's saved version of REGNUM 270 has a known constant (computed) value of ADDR. Convert the 271 CORE_ADDR to a target address if necessary. */ 272 273 struct value * 274 frame_unwind_got_address (struct frame_info *frame, int regnum, 275 CORE_ADDR addr) 276 { 277 struct gdbarch *gdbarch = frame_unwind_arch (frame); 278 struct value *reg_val; 279 280 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 281 pack_long (value_contents_writeable (reg_val), 282 register_type (gdbarch, regnum), addr); 283 return reg_val; 284 } 285 286 /* -Wmissing-prototypes */ 287 extern initialize_file_ftype _initialize_frame_unwind; 288 289 void 290 _initialize_frame_unwind (void) 291 { 292 frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init); 293 } 294