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