1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free 5 Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24 25 #include "defs.h" 26 #include "dummy-frame.h" 27 #include "regcache.h" 28 #include "frame.h" 29 #include "inferior.h" 30 #include "gdb_assert.h" 31 #include "frame-unwind.h" 32 #include "command.h" 33 #include "gdbcmd.h" 34 #include "gdb_string.h" 35 36 /* Dummy frame. This saves the processor state just prior to setting 37 up the inferior function call. Older targets save the registers 38 on the target stack (but that really slows down function calls). */ 39 40 struct dummy_frame 41 { 42 struct dummy_frame *next; 43 /* This frame's ID. Must match the value returned by 44 gdbarch_unwind_dummy_id. */ 45 struct frame_id id; 46 /* The caller's regcache. */ 47 struct regcache *regcache; 48 }; 49 50 static struct dummy_frame *dummy_frame_stack = NULL; 51 52 /* Function: deprecated_pc_in_call_dummy (pc) 53 54 Return non-zero if the PC falls in a dummy frame created by gdb for 55 an inferior call. The code below which allows DECR_PC_AFTER_BREAK 56 is for infrun.c, which may give the function a PC without that 57 subtracted out. 58 59 FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can 60 figure out what the real PC (as in the resume address) is BEFORE 61 calling this function. 62 63 NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of 64 infrun.c:adjust_pc_after_break (thanks), this function is now 65 always called with a correctly adjusted PC! 66 67 NOTE: cagney/2004-08-02: Code should not need to call this. */ 68 69 int 70 deprecated_pc_in_call_dummy (CORE_ADDR pc) 71 { 72 struct dummy_frame *dummyframe; 73 for (dummyframe = dummy_frame_stack; 74 dummyframe != NULL; 75 dummyframe = dummyframe->next) 76 { 77 if ((pc >= dummyframe->id.code_addr) 78 && (pc <= dummyframe->id.code_addr + DECR_PC_AFTER_BREAK)) 79 return 1; 80 } 81 return 0; 82 } 83 84 /* Push the caller's state, along with the dummy frame info, onto a 85 dummy-frame stack. */ 86 87 void 88 dummy_frame_push (struct regcache *caller_regcache, 89 const struct frame_id *dummy_id) 90 { 91 struct dummy_frame *dummy_frame; 92 93 /* Check to see if there are stale dummy frames, perhaps left over 94 from when a longjump took us out of a function that was called by 95 the debugger. */ 96 dummy_frame = dummy_frame_stack; 97 while (dummy_frame) 98 /* FIXME: cagney/2004-08-02: Should just test IDs. */ 99 if (frame_id_inner (dummy_frame->id, (*dummy_id))) 100 /* Stale -- destroy! */ 101 { 102 dummy_frame_stack = dummy_frame->next; 103 regcache_xfree (dummy_frame->regcache); 104 xfree (dummy_frame); 105 dummy_frame = dummy_frame_stack; 106 } 107 else 108 dummy_frame = dummy_frame->next; 109 110 dummy_frame = XZALLOC (struct dummy_frame); 111 dummy_frame->regcache = caller_regcache; 112 dummy_frame->id = (*dummy_id); 113 dummy_frame->next = dummy_frame_stack; 114 dummy_frame_stack = dummy_frame; 115 } 116 117 /* Return the dummy frame cache, it contains both the ID, and a 118 pointer to the regcache. */ 119 struct dummy_frame_cache 120 { 121 struct frame_id this_id; 122 struct regcache *prev_regcache; 123 }; 124 125 int 126 dummy_frame_sniffer (const struct frame_unwind *self, 127 struct frame_info *next_frame, 128 void **this_prologue_cache) 129 { 130 struct dummy_frame *dummyframe; 131 struct frame_id this_id; 132 133 /* When unwinding a normal frame, the stack structure is determined 134 by analyzing the frame's function's code (be it using brute force 135 prologue analysis, or the dwarf2 CFI). In the case of a dummy 136 frame, that simply isn't possible. The PC is either the program 137 entry point, or some random address on the stack. Trying to use 138 that PC to apply standard frame ID unwind techniques is just 139 asking for trouble. */ 140 /* Use an architecture specific method to extract the prev's dummy 141 ID from the next frame. Note that this method uses 142 frame_register_unwind to obtain the register values needed to 143 determine the dummy frame's ID. */ 144 this_id = gdbarch_unwind_dummy_id (get_frame_arch (next_frame), next_frame); 145 146 /* Use that ID to find the corresponding cache entry. */ 147 for (dummyframe = dummy_frame_stack; 148 dummyframe != NULL; 149 dummyframe = dummyframe->next) 150 { 151 if (frame_id_eq (dummyframe->id, this_id)) 152 { 153 struct dummy_frame_cache *cache; 154 cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache); 155 cache->prev_regcache = dummyframe->regcache; 156 cache->this_id = this_id; 157 (*this_prologue_cache) = cache; 158 return 1; 159 } 160 } 161 return 0; 162 } 163 164 /* Given a call-dummy dummy-frame, return the registers. Here the 165 register value is taken from the local copy of the register buffer. */ 166 167 static void 168 dummy_frame_prev_register (struct frame_info *next_frame, 169 void **this_prologue_cache, 170 int regnum, int *optimized, 171 enum lval_type *lvalp, CORE_ADDR *addrp, 172 int *realnum, void *bufferp) 173 { 174 /* The dummy-frame sniffer always fills in the cache. */ 175 struct dummy_frame_cache *cache = (*this_prologue_cache); 176 gdb_assert (cache != NULL); 177 178 /* Describe the register's location. Generic dummy frames always 179 have the register value in an ``expression''. */ 180 *optimized = 0; 181 *lvalp = not_lval; 182 *addrp = 0; 183 *realnum = -1; 184 185 /* If needed, find and return the value of the register. */ 186 if (bufferp != NULL) 187 { 188 /* Return the actual value. */ 189 /* Use the regcache_cooked_read() method so that it, on the fly, 190 constructs either a raw or pseudo register from the raw 191 register cache. */ 192 regcache_cooked_read (cache->prev_regcache, regnum, bufferp); 193 } 194 } 195 196 /* Assuming that THIS frame is a dummy (remember, the NEXT and not 197 THIS frame is passed in), return the ID of THIS frame. That ID is 198 determined by examining the NEXT frame's unwound registers using 199 the method unwind_dummy_id(). As a side effect, THIS dummy frame's 200 dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */ 201 202 static void 203 dummy_frame_this_id (struct frame_info *next_frame, 204 void **this_prologue_cache, 205 struct frame_id *this_id) 206 { 207 /* The dummy-frame sniffer always fills in the cache. */ 208 struct dummy_frame_cache *cache = (*this_prologue_cache); 209 gdb_assert (cache != NULL); 210 (*this_id) = cache->this_id; 211 } 212 213 static const struct frame_unwind dummy_frame_unwinder = 214 { 215 DUMMY_FRAME, 216 dummy_frame_this_id, 217 dummy_frame_prev_register, 218 NULL, 219 dummy_frame_sniffer, 220 }; 221 222 const struct frame_unwind *const dummy_frame_unwind = { 223 &dummy_frame_unwinder 224 }; 225 226 static void 227 fprint_dummy_frames (struct ui_file *file) 228 { 229 struct dummy_frame *s; 230 for (s = dummy_frame_stack; s != NULL; s = s->next) 231 { 232 gdb_print_host_address (s, file); 233 fprintf_unfiltered (file, ":"); 234 fprintf_unfiltered (file, " id="); 235 fprint_frame_id (file, s->id); 236 fprintf_unfiltered (file, "\n"); 237 } 238 } 239 240 static void 241 maintenance_print_dummy_frames (char *args, int from_tty) 242 { 243 if (args == NULL) 244 fprint_dummy_frames (gdb_stdout); 245 else 246 { 247 struct ui_file *file = gdb_fopen (args, "w"); 248 if (file == NULL) 249 perror_with_name ("maintenance print dummy-frames"); 250 fprint_dummy_frames (file); 251 ui_file_delete (file); 252 } 253 } 254 255 extern void _initialize_dummy_frame (void); 256 257 void 258 _initialize_dummy_frame (void) 259 { 260 add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames, 261 "Print the contents of the internal dummy-frame stack.", 262 &maintenanceprintlist); 263 264 } 265