gdb/dummy-frame.c

   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 static int pc_in_dummy_frame (CORE_ADDR pc);
  37
  38 /* Dummy frame.  This saves the processor state just prior to setting
  39    up the inferior function call.  Older targets save the registers
  40    on the target stack (but that really slows down function calls).  */
  41
  42 struct dummy_frame
  43 {
  44   struct dummy_frame *next;
  45
  46   /* These values belong to the caller (the previous frame, the frame
  47      that this unwinds back to).  */
  48   CORE_ADDR pc;
  49   CORE_ADDR top;
  50   struct frame_id id;
  51   struct regcache *regcache;
  52
  53   /* Address range of the call dummy code.  Look for PC in the range
  54      [LO..HI) (after allowing for DECR_PC_AFTER_BREAK).  */
  55   CORE_ADDR call_lo;
  56   CORE_ADDR call_hi;
  57 };
  58
  59 static struct dummy_frame *dummy_frame_stack = NULL;
  60
  61 /* Function: pc_in_call_dummy (pc)
  62
  63    Return true if the PC falls in a dummy frame created by gdb for an
  64    inferior call.  The code below which allows DECR_PC_AFTER_BREAK is
  65    for infrun.c, which may give the function a PC without that
  66    subtracted out.  */
  67
  68 int
  69 deprecated_pc_in_call_dummy (CORE_ADDR pc)
  70 {
  71   return pc_in_dummy_frame (pc);
  72 }
  73
  74 /* Return non-zero if the PC falls in a dummy frame.
  75
  76    The code below which allows DECR_PC_AFTER_BREAK is for infrun.c,
  77    which may give the function a PC without that subtracted out.
  78
  79    FIXME: cagney/2002-11-23: This is silly.  Surely "infrun.c" can
  80    figure out what the real PC (as in the resume address) is BEFORE
  81    calling this function.  */
  82
  83 static int
  84 pc_in_dummy_frame (CORE_ADDR pc)
  85 {
  86   struct dummy_frame *dummyframe;
  87   for (dummyframe = dummy_frame_stack;
  88        dummyframe != NULL;
  89        dummyframe = dummyframe->next)
  90     {
  91       if ((pc >= dummyframe->call_lo)
  92           && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
  93         return 1;
  94     }
  95   return 0;
  96 }
  97
  98 /* Push the caller's state, along with the dummy frame info, onto a
  99    dummy-frame stack.  */
 100
 101 void
 102 dummy_frame_push (struct regcache *caller_regcache,
 103                   const struct frame_id *dummy_id)
 104 {
 105   struct dummy_frame *dummy_frame;
 106
 107   /* Check to see if there are stale dummy frames, perhaps left over
 108      from when a longjump took us out of a function that was called by
 109      the debugger.  */
 110   dummy_frame = dummy_frame_stack;
 111   while (dummy_frame)
 112     /* FIXME: cagney/2004-08-02: Should just test IDs.  */
 113     if (gdbarch_inner_than (current_gdbarch, dummy_frame->top,
 114                             dummy_id->stack_addr))
 115       /* Stale -- destroy!  */
 116       {
 117         dummy_frame_stack = dummy_frame->next;
 118         regcache_xfree (dummy_frame->regcache);
 119         xfree (dummy_frame);
 120         dummy_frame = dummy_frame_stack;
 121       }
 122     else
 123       dummy_frame = dummy_frame->next;
 124
 125   dummy_frame = XZALLOC (struct dummy_frame);
 126   dummy_frame->regcache = caller_regcache;
 127   dummy_frame->id = (*dummy_id);
 128   /* FIXME: cagney/2004-08-02: Retain for compatibility - trust the
 129      ID.  */
 130   dummy_frame->pc = dummy_id->code_addr;
 131   dummy_frame->top = dummy_id->stack_addr;
 132   dummy_frame->call_lo = dummy_id->code_addr + 0;
 133   dummy_frame->call_hi = dummy_id->code_addr + 1;
 134   dummy_frame->next = dummy_frame_stack;
 135   dummy_frame_stack = dummy_frame;
 136 }
 137
 138 /* Return the dummy frame cache, it contains both the ID, and a
 139    pointer to the regcache.  */
 140 struct dummy_frame_cache
 141 {
 142   struct frame_id this_id;
 143   struct regcache *prev_regcache;
 144 };
 145
 146 int
 147 dummy_frame_sniffer (const struct frame_unwind *self,
 148                      struct frame_info *next_frame,
 149                      void **this_prologue_cache)
 150 {
 151   struct dummy_frame *dummyframe;
 152   struct frame_id this_id;
 153
 154   /* When unwinding a normal frame, the stack structure is determined
 155      by analyzing the frame's function's code (be it using brute force
 156      prologue analysis, or the dwarf2 CFI).  In the case of a dummy
 157      frame, that simply isn't possible.  The PC is either the program
 158      entry point, or some random address on the stack.  Trying to use
 159      that PC to apply standard frame ID unwind techniques is just
 160      asking for trouble.  */
 161   /* Use an architecture specific method to extract the prev's dummy
 162      ID from the next frame.  Note that this method uses
 163      frame_register_unwind to obtain the register values needed to
 164      determine the dummy frame's ID.  */
 165   this_id = gdbarch_unwind_dummy_id (get_frame_arch (next_frame), next_frame);
 166
 167   /* Use that ID to find the corresponding cache entry.  */
 168   for (dummyframe = dummy_frame_stack;
 169        dummyframe != NULL;
 170        dummyframe = dummyframe->next)
 171     {
 172       /* Does the PC fall within the dummy frame's breakpoint
 173          instruction.  If not, discard this one.  */
 174       if (!(this_id.code_addr >= dummyframe->call_lo
 175             && this_id.code_addr < dummyframe->call_hi))
 176         continue;
 177       /* Does the FP match?  "infcall.c" explicitly saved the
 178          top-of-stack before the inferior function call, assume
 179          unwind_dummy_id() returns that same stack value.  */
 180       if (this_id.stack_addr != dummyframe->top)
 181         continue;
 182       /* The FP matches this dummy frame.  */
 183       {
 184         struct dummy_frame_cache *cache;
 185         cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
 186         cache->prev_regcache = dummyframe->regcache;
 187         cache->this_id = this_id;
 188         (*this_prologue_cache) = cache;
 189         return 1;
 190       }
 191     }
 192   return 0;
 193 }
 194
 195 /* Given a call-dummy dummy-frame, return the registers.  Here the
 196    register value is taken from the local copy of the register buffer.  */
 197
 198 static void
 199 dummy_frame_prev_register (struct frame_info *next_frame,
 200                            void **this_prologue_cache,
 201                            int regnum, int *optimized,
 202                            enum lval_type *lvalp, CORE_ADDR *addrp,
 203                            int *realnum, void *bufferp)
 204 {
 205   /* The dummy-frame sniffer always fills in the cache.  */
 206   struct dummy_frame_cache *cache = (*this_prologue_cache);
 207   gdb_assert (cache != NULL);
 208
 209   /* Describe the register's location.  Generic dummy frames always
 210      have the register value in an ``expression''.  */
 211   *optimized = 0;
 212   *lvalp = not_lval;
 213   *addrp = 0;
 214   *realnum = -1;
 215
 216   /* If needed, find and return the value of the register.  */
 217   if (bufferp != NULL)
 218     {
 219       /* Return the actual value.  */
 220       /* Use the regcache_cooked_read() method so that it, on the fly,
 221          constructs either a raw or pseudo register from the raw
 222          register cache.  */
 223       regcache_cooked_read (cache->prev_regcache, regnum, bufferp);
 224     }
 225 }
 226
 227 /* Assuming that THIS frame is a dummy (remember, the NEXT and not
 228    THIS frame is passed in), return the ID of THIS frame.  That ID is
 229    determined by examining the NEXT frame's unwound registers using
 230    the method unwind_dummy_id().  As a side effect, THIS dummy frame's
 231    dummy cache is located and and saved in THIS_PROLOGUE_CACHE.  */
 232
 233 static void
 234 dummy_frame_this_id (struct frame_info *next_frame,
 235                      void **this_prologue_cache,
 236                      struct frame_id *this_id)
 237 {
 238   /* The dummy-frame sniffer always fills in the cache.  */
 239   struct dummy_frame_cache *cache = (*this_prologue_cache);
 240   gdb_assert (cache != NULL);
 241   (*this_id) = cache->this_id;
 242 }
 243
 244 static const struct frame_unwind dummy_frame_unwinder =
 245 {
 246   DUMMY_FRAME,
 247   dummy_frame_this_id,
 248   dummy_frame_prev_register,
 249   NULL,
 250   dummy_frame_sniffer,
 251 };
 252
 253 const struct frame_unwind *const dummy_frame_unwind = {
 254   &dummy_frame_unwinder
 255 };
 256
 257 static void
 258 fprint_dummy_frames (struct ui_file *file)
 259 {
 260   struct dummy_frame *s;
 261   for (s = dummy_frame_stack; s != NULL; s = s->next)
 262     {
 263       gdb_print_host_address (s, file);
 264       fprintf_unfiltered (file, ":");
 265       fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc));
 266       fprintf_unfiltered (file, " top=0x%s", paddr (s->top));
 267       fprintf_unfiltered (file, " id=");
 268       fprint_frame_id (file, s->id);
 269       fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo));
 270       fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi));
 271       fprintf_unfiltered (file, "\n");
 272     }
 273 }
 274
 275 static void
 276 maintenance_print_dummy_frames (char *args, int from_tty)
 277 {
 278   if (args == NULL)
 279     fprint_dummy_frames (gdb_stdout);
 280   else
 281     {
 282       struct ui_file *file = gdb_fopen (args, "w");
 283       if (file == NULL)
 284         perror_with_name ("maintenance print dummy-frames");
 285       fprint_dummy_frames (file);
 286       ui_file_delete (file);
 287     }
 288 }
 289
 290 extern void _initialize_dummy_frame (void);
 291
 292 void
 293 _initialize_dummy_frame (void)
 294 {
 295   add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
 296            "Print the contents of the internal dummy-frame stack.",
 297            &maintenanceprintlist);
 298
 299 }