1 /* Definitions for frame unwinder, for GDB, the GNU debugger. 2 3 Copyright (C) 2003-2020 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 #include "gdbarch.h" 30 #include "dwarf2/frame-tailcall.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 /* A helper function to add an unwinder to a list. LINK says where to 48 install the new unwinder. The new link is returned. */ 49 50 static struct frame_unwind_table_entry ** 51 add_unwinder (struct obstack *obstack, const struct frame_unwind *unwinder, 52 struct frame_unwind_table_entry **link) 53 { 54 *link = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); 55 (*link)->unwinder = unwinder; 56 return &(*link)->next; 57 } 58 59 static void * 60 frame_unwind_init (struct obstack *obstack) 61 { 62 struct frame_unwind_table *table 63 = OBSTACK_ZALLOC (obstack, struct frame_unwind_table); 64 65 /* Start the table out with a few default sniffers. OSABI code 66 can't override this. */ 67 struct frame_unwind_table_entry **link = &table->list; 68 69 link = add_unwinder (obstack, &dummy_frame_unwind, link); 70 /* The DWARF tailcall sniffer must come before the inline sniffer. 71 Otherwise, we can end up in a situation where a DWARF frame finds 72 tailcall information, but then the inline sniffer claims a frame 73 before the tailcall sniffer, resulting in confusion. This is 74 safe to do always because the tailcall sniffer can only ever be 75 activated if the newer frame was created using the DWARF 76 unwinder, and it also found tailcall information. */ 77 link = add_unwinder (obstack, &dwarf2_tailcall_frame_unwind, link); 78 link = add_unwinder (obstack, &inline_frame_unwind, link); 79 80 /* The insertion point for OSABI sniffers. */ 81 table->osabi_head = link; 82 return table; 83 } 84 85 void 86 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, 87 const struct frame_unwind *unwinder) 88 { 89 struct frame_unwind_table *table 90 = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data); 91 struct frame_unwind_table_entry *entry; 92 93 /* Insert the new entry at the start of the list. */ 94 entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 95 entry->unwinder = unwinder; 96 entry->next = (*table->osabi_head); 97 (*table->osabi_head) = entry; 98 } 99 100 void 101 frame_unwind_append_unwinder (struct gdbarch *gdbarch, 102 const struct frame_unwind *unwinder) 103 { 104 struct frame_unwind_table *table 105 = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data); 106 struct frame_unwind_table_entry **ip; 107 108 /* Find the end of the list and insert the new entry there. */ 109 for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); 110 (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 111 (*ip)->unwinder = unwinder; 112 } 113 114 /* Call SNIFFER from UNWINDER. If it succeeded set UNWINDER for 115 THIS_FRAME and return 1. Otherwise the function keeps THIS_FRAME 116 unchanged and returns 0. */ 117 118 static int 119 frame_unwind_try_unwinder (struct frame_info *this_frame, void **this_cache, 120 const struct frame_unwind *unwinder) 121 { 122 int res = 0; 123 124 unsigned int entry_generation = get_frame_cache_generation (); 125 126 frame_prepare_for_sniffer (this_frame, unwinder); 127 128 try 129 { 130 res = unwinder->sniffer (unwinder, this_frame, this_cache); 131 } 132 catch (const gdb_exception &ex) 133 { 134 /* Catch all exceptions, caused by either interrupt or error. 135 Reset *THIS_CACHE, unless something reinitialized the frame 136 cache meanwhile, in which case THIS_FRAME/THIS_CACHE are now 137 dangling. */ 138 if (get_frame_cache_generation () == entry_generation) 139 { 140 *this_cache = NULL; 141 frame_cleanup_after_sniffer (this_frame); 142 } 143 144 if (ex.error == NOT_AVAILABLE_ERROR) 145 { 146 /* This usually means that not even the PC is available, 147 thus most unwinders aren't able to determine if they're 148 the best fit. Keep trying. Fallback prologue unwinders 149 should always accept the frame. */ 150 return 0; 151 } 152 throw; 153 } 154 155 if (res) 156 return 1; 157 else 158 { 159 /* Don't set *THIS_CACHE to NULL here, because sniffer has to do 160 so. */ 161 frame_cleanup_after_sniffer (this_frame); 162 return 0; 163 } 164 gdb_assert_not_reached ("frame_unwind_try_unwinder"); 165 } 166 167 /* Iterate through sniffers for THIS_FRAME frame until one returns with an 168 unwinder implementation. THIS_FRAME->UNWIND must be NULL, it will get set 169 by this function. Possibly initialize THIS_CACHE. */ 170 171 void 172 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache) 173 { 174 struct gdbarch *gdbarch = get_frame_arch (this_frame); 175 struct frame_unwind_table *table 176 = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data); 177 struct frame_unwind_table_entry *entry; 178 const struct frame_unwind *unwinder_from_target; 179 180 unwinder_from_target = target_get_unwinder (); 181 if (unwinder_from_target != NULL 182 && frame_unwind_try_unwinder (this_frame, this_cache, 183 unwinder_from_target)) 184 return; 185 186 unwinder_from_target = target_get_tailcall_unwinder (); 187 if (unwinder_from_target != NULL 188 && frame_unwind_try_unwinder (this_frame, this_cache, 189 unwinder_from_target)) 190 return; 191 192 for (entry = table->list; entry != NULL; entry = entry->next) 193 if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder)) 194 return; 195 196 internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); 197 } 198 199 /* A default frame sniffer which always accepts the frame. Used by 200 fallback prologue unwinders. */ 201 202 int 203 default_frame_sniffer (const struct frame_unwind *self, 204 struct frame_info *this_frame, 205 void **this_prologue_cache) 206 { 207 return 1; 208 } 209 210 /* The default frame unwinder stop_reason callback. */ 211 212 enum unwind_stop_reason 213 default_frame_unwind_stop_reason (struct frame_info *this_frame, 214 void **this_cache) 215 { 216 struct frame_id this_id = get_frame_id (this_frame); 217 218 if (frame_id_eq (this_id, outer_frame_id)) 219 return UNWIND_OUTERMOST; 220 else 221 return UNWIND_NO_REASON; 222 } 223 224 /* See frame-unwind.h. */ 225 226 CORE_ADDR 227 default_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 228 { 229 int pc_regnum = gdbarch_pc_regnum (gdbarch); 230 CORE_ADDR pc = frame_unwind_register_unsigned (next_frame, pc_regnum); 231 pc = gdbarch_addr_bits_remove (gdbarch, pc); 232 return pc; 233 } 234 235 /* See frame-unwind.h. */ 236 237 CORE_ADDR 238 default_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 239 { 240 int sp_regnum = gdbarch_sp_regnum (gdbarch); 241 return frame_unwind_register_unsigned (next_frame, sp_regnum); 242 } 243 244 /* Helper functions for value-based register unwinding. These return 245 a (possibly lazy) value of the appropriate type. */ 246 247 /* Return a value which indicates that FRAME did not save REGNUM. */ 248 249 struct value * 250 frame_unwind_got_optimized (struct frame_info *frame, int regnum) 251 { 252 struct gdbarch *gdbarch = frame_unwind_arch (frame); 253 struct type *type = register_type (gdbarch, regnum); 254 255 return allocate_optimized_out_value (type); 256 } 257 258 /* Return a value which indicates that FRAME copied REGNUM into 259 register NEW_REGNUM. */ 260 261 struct value * 262 frame_unwind_got_register (struct frame_info *frame, 263 int regnum, int new_regnum) 264 { 265 return value_of_register_lazy (frame, new_regnum); 266 } 267 268 /* Return a value which indicates that FRAME saved REGNUM in memory at 269 ADDR. */ 270 271 struct value * 272 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) 273 { 274 struct gdbarch *gdbarch = frame_unwind_arch (frame); 275 struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); 276 277 set_value_stack (v, 1); 278 return v; 279 } 280 281 /* Return a value which indicates that FRAME's saved version of 282 REGNUM has a known constant (computed) value of VAL. */ 283 284 struct value * 285 frame_unwind_got_constant (struct frame_info *frame, int regnum, 286 ULONGEST val) 287 { 288 struct gdbarch *gdbarch = frame_unwind_arch (frame); 289 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 290 struct value *reg_val; 291 292 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 293 store_unsigned_integer (value_contents_writeable (reg_val), 294 register_size (gdbarch, regnum), byte_order, val); 295 return reg_val; 296 } 297 298 struct value * 299 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) 300 { 301 struct gdbarch *gdbarch = frame_unwind_arch (frame); 302 struct value *reg_val; 303 304 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 305 memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); 306 return reg_val; 307 } 308 309 /* Return a value which indicates that FRAME's saved version of REGNUM 310 has a known constant (computed) value of ADDR. Convert the 311 CORE_ADDR to a target address if necessary. */ 312 313 struct value * 314 frame_unwind_got_address (struct frame_info *frame, int regnum, 315 CORE_ADDR addr) 316 { 317 struct gdbarch *gdbarch = frame_unwind_arch (frame); 318 struct value *reg_val; 319 320 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 321 pack_long (value_contents_writeable (reg_val), 322 register_type (gdbarch, regnum), addr); 323 return reg_val; 324 } 325 326 void _initialize_frame_unwind (); 327 void 328 _initialize_frame_unwind () 329 { 330 frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init); 331 } 332