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