1 /* Definitions for frame unwinder, for GDB, the GNU debugger. 2 3 Copyright (C) 2003, 2004, 2007, 2008, 2009 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 28 #include "gdb_assert.h" 29 #include "gdb_obstack.h" 30 31 static struct gdbarch_data *frame_unwind_data; 32 33 struct frame_unwind_table_entry 34 { 35 const struct frame_unwind *unwinder; 36 struct frame_unwind_table_entry *next; 37 }; 38 39 struct frame_unwind_table 40 { 41 struct frame_unwind_table_entry *list; 42 /* The head of the OSABI part of the search list. */ 43 struct frame_unwind_table_entry **osabi_head; 44 }; 45 46 static void * 47 frame_unwind_init (struct obstack *obstack) 48 { 49 struct frame_unwind_table *table 50 = OBSTACK_ZALLOC (obstack, struct frame_unwind_table); 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, struct frame_unwind_table_entry); 56 table->list->next->unwinder = inline_frame_unwind; 57 /* The insertion point for OSABI sniffers. */ 58 table->osabi_head = &table->list->next->next; 59 return table; 60 } 61 62 void 63 frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, 64 const struct frame_unwind *unwinder) 65 { 66 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 67 struct frame_unwind_table_entry *entry; 68 69 /* Insert the new entry at the start of the list. */ 70 entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 71 entry->unwinder = unwinder; 72 entry->next = (*table->osabi_head); 73 (*table->osabi_head) = entry; 74 } 75 76 void 77 frame_unwind_append_unwinder (struct gdbarch *gdbarch, 78 const struct frame_unwind *unwinder) 79 { 80 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 81 struct frame_unwind_table_entry **ip; 82 83 /* Find the end of the list and insert the new entry there. */ 84 for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); 85 (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); 86 (*ip)->unwinder = unwinder; 87 } 88 89 const struct frame_unwind * 90 frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache) 91 { 92 int i; 93 struct gdbarch *gdbarch = get_frame_arch (this_frame); 94 struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); 95 struct frame_unwind_table_entry *entry; 96 struct cleanup *old_cleanup; 97 for (entry = table->list; entry != NULL; entry = entry->next) 98 { 99 struct cleanup *old_cleanup; 100 101 old_cleanup = frame_prepare_for_sniffer (this_frame, entry->unwinder); 102 if (entry->unwinder->sniffer (entry->unwinder, this_frame, 103 this_cache)) 104 { 105 discard_cleanups (old_cleanup); 106 return entry->unwinder; 107 } 108 do_cleanups (old_cleanup); 109 } 110 internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); 111 } 112 113 /* A default frame sniffer which always accepts the frame. Used by 114 fallback prologue unwinders. */ 115 116 int 117 default_frame_sniffer (const struct frame_unwind *self, 118 struct frame_info *this_frame, 119 void **this_prologue_cache) 120 { 121 return 1; 122 } 123 124 /* Helper functions for value-based register unwinding. These return 125 a (possibly lazy) value of the appropriate type. */ 126 127 /* Return a value which indicates that FRAME did not save REGNUM. */ 128 129 struct value * 130 frame_unwind_got_optimized (struct frame_info *frame, int regnum) 131 { 132 struct gdbarch *gdbarch = frame_unwind_arch (frame); 133 struct value *reg_val; 134 135 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 136 set_value_optimized_out (reg_val, 1); 137 return reg_val; 138 } 139 140 /* Return a value which indicates that FRAME copied REGNUM into 141 register NEW_REGNUM. */ 142 143 struct value * 144 frame_unwind_got_register (struct frame_info *frame, int regnum, int new_regnum) 145 { 146 return value_of_register_lazy (frame, new_regnum); 147 } 148 149 /* Return a value which indicates that FRAME saved REGNUM in memory at 150 ADDR. */ 151 152 struct value * 153 frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) 154 { 155 struct gdbarch *gdbarch = frame_unwind_arch (frame); 156 struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); 157 158 set_value_stack (v, 1); 159 return v; 160 } 161 162 /* Return a value which indicates that FRAME's saved version of 163 REGNUM has a known constant (computed) value of VAL. */ 164 165 struct value * 166 frame_unwind_got_constant (struct frame_info *frame, int regnum, 167 ULONGEST val) 168 { 169 struct gdbarch *gdbarch = frame_unwind_arch (frame); 170 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 171 struct value *reg_val; 172 173 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 174 store_unsigned_integer (value_contents_writeable (reg_val), 175 register_size (gdbarch, regnum), byte_order, val); 176 return reg_val; 177 } 178 179 struct value * 180 frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) 181 { 182 struct gdbarch *gdbarch = frame_unwind_arch (frame); 183 struct value *reg_val; 184 185 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 186 memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); 187 return reg_val; 188 } 189 190 /* Return a value which indicates that FRAME's saved version of REGNUM 191 has a known constant (computed) value of ADDR. Convert the 192 CORE_ADDR to a target address if necessary. */ 193 194 struct value * 195 frame_unwind_got_address (struct frame_info *frame, int regnum, 196 CORE_ADDR addr) 197 { 198 struct gdbarch *gdbarch = frame_unwind_arch (frame); 199 struct value *reg_val; 200 201 reg_val = value_zero (register_type (gdbarch, regnum), not_lval); 202 pack_long (value_contents_writeable (reg_val), 203 register_type (gdbarch, regnum), addr); 204 return reg_val; 205 } 206 207 extern initialize_file_ftype _initialize_frame_unwind; /* -Wmissing-prototypes */ 208 209 void 210 _initialize_frame_unwind (void) 211 { 212 frame_unwind_data = gdbarch_data_register_pre_init (frame_unwind_init); 213 } 214