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