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 Free Software
   5    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
  32 /* Dummy frame.  This saves the processor state just prior to setting
  33    up the inferior function call.  Older targets save the registers
  34    on the target stack (but that really slows down function calls).  */
  35
  36 struct dummy_frame
  37 {
  38   struct dummy_frame *next;
  39
  40   CORE_ADDR pc;
  41   CORE_ADDR fp;
  42   CORE_ADDR sp;
  43   CORE_ADDR top;
  44   struct regcache *regcache;
  45
  46   /* Address range of the call dummy code.  Look for PC in the range
  47      [LO..HI) (after allowing for DECR_PC_AFTER_BREAK).  */
  48   CORE_ADDR call_lo;
  49   CORE_ADDR call_hi;
  50 };
  51
  52 static struct dummy_frame *dummy_frame_stack = NULL;
  53
  54 /* Function: find_dummy_frame(pc, fp, sp)
  55
  56    Search the stack of dummy frames for one matching the given PC and
  57    FP/SP.  Unlike PC_IN_CALL_DUMMY, this function doesn't need to
  58    adjust for DECR_PC_AFTER_BREAK.  This is because it is only legal
  59    to call this function after the PC has been adjusted.  */
  60
  61 static struct dummy_frame *
  62 find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
  63 {
  64   struct dummy_frame *dummyframe;
  65
  66   for (dummyframe = dummy_frame_stack; dummyframe != NULL;
  67        dummyframe = dummyframe->next)
  68     {
  69       /* Does the PC fall within the dummy frame's breakpoint
  70          instruction.  If not, discard this one.  */
  71       if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi))
  72         continue;
  73       /* Does the FP match?  */
  74       if (dummyframe->top != 0)
  75         {
  76           /* If the target architecture explicitly saved the
  77              top-of-stack before the inferior function call, assume
  78              that that same architecture will always pass in an FP
  79              (frame base) value that eactly matches that saved TOS.
  80              Don't check the saved SP and SP as they can lead to false
  81              hits.  */
  82           if (fp != dummyframe->top)
  83             continue;
  84         }
  85       else
  86         {
  87           /* An older target that hasn't explicitly or implicitly
  88              saved the dummy frame's top-of-stack.  Try matching the
  89              FP against the saved SP and FP.  NOTE: If you're trying
  90              to fix a problem with GDB not correctly finding a dummy
  91              frame, check the comments that go with FRAME_ALIGN() and
  92              SAVE_DUMMY_FRAME_TOS().  */
  93           if (fp != dummyframe->fp && fp != dummyframe->sp)
  94             continue;
  95         }
  96       /* The FP matches this dummy frame.  */
  97       return dummyframe;
  98     }
  99
 100   return NULL;
 101 }
 102
 103 struct dummy_frame *
 104 cached_find_dummy_frame (struct frame_info *frame, void **cache)
 105 {
 106   if ((*cache) == NULL)
 107     (*cache) = find_dummy_frame (frame->pc, frame->frame);
 108   return (*cache);
 109 }
 110
 111 struct regcache *
 112 generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
 113 {
 114   struct dummy_frame *dummy = find_dummy_frame (pc, fp);
 115   if (dummy != NULL)
 116     return dummy->regcache;
 117   else
 118     return NULL;
 119 }
 120
 121 char *
 122 deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
 123 {
 124   struct regcache *regcache = generic_find_dummy_frame (pc, fp);
 125   if (regcache == NULL)
 126     return NULL;
 127   return deprecated_grub_regcache_for_registers (regcache);
 128 }
 129
 130 /* Function: pc_in_call_dummy (pc, sp, fp)
 131
 132    Return true if the PC falls in a dummy frame created by gdb for an
 133    inferior call.  The code below which allows DECR_PC_AFTER_BREAK is
 134    for infrun.c, which may give the function a PC without that
 135    subtracted out.  */
 136
 137 int
 138 generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
 139 {
 140   struct dummy_frame *dummyframe;
 141   for (dummyframe = dummy_frame_stack;
 142        dummyframe != NULL;
 143        dummyframe = dummyframe->next)
 144     {
 145       if ((pc >= dummyframe->call_lo)
 146           && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
 147         return 1;
 148     }
 149   return 0;
 150 }
 151
 152 /* Function: read_register_dummy
 153    Find a saved register from before GDB calls a function in the inferior */
 154
 155 CORE_ADDR
 156 deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
 157 {
 158   struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
 159
 160   if (dummy_regs)
 161     {
 162       /* NOTE: cagney/2002-08-12: Replaced a call to
 163          regcache_raw_read_as_address() with a call to
 164          regcache_cooked_read_unsigned().  The old, ...as_address
 165          function was eventually calling extract_unsigned_integer (via
 166          extract_address) to unpack the registers value.  The below is
 167          doing an unsigned extract so that it is functionally
 168          equivalent.  The read needs to be cooked as, otherwise, it
 169          will never correctly return the value of a register in the
 170          [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range.  */
 171       ULONGEST val;
 172       regcache_cooked_read_unsigned (dummy_regs, regno, &val);
 173       return val;
 174     }
 175   else
 176     return 0;
 177 }
 178
 179 /* Save all the registers on the dummy frame stack.  Most ports save the
 180    registers on the target stack.  This results in lots of unnecessary memory
 181    references, which are slow when debugging via a serial line.  Instead, we
 182    save all the registers internally, and never write them to the stack.  The
 183    registers get restored when the called function returns to the entry point,
 184    where a breakpoint is laying in wait.  */
 185
 186 void
 187 generic_push_dummy_frame (void)
 188 {
 189   struct dummy_frame *dummy_frame;
 190   CORE_ADDR fp = (get_current_frame ())->frame;
 191
 192   /* check to see if there are stale dummy frames,
 193      perhaps left over from when a longjump took us out of a
 194      function that was called by the debugger */
 195
 196   dummy_frame = dummy_frame_stack;
 197   while (dummy_frame)
 198     if (INNER_THAN (dummy_frame->fp, fp))       /* stale -- destroy! */
 199       {
 200         dummy_frame_stack = dummy_frame->next;
 201         regcache_xfree (dummy_frame->regcache);
 202         xfree (dummy_frame);
 203         dummy_frame = dummy_frame_stack;
 204       }
 205     else
 206       dummy_frame = dummy_frame->next;
 207
 208   dummy_frame = xmalloc (sizeof (struct dummy_frame));
 209   dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
 210
 211   dummy_frame->pc = read_pc ();
 212   dummy_frame->sp = read_sp ();
 213   dummy_frame->top = 0;
 214   dummy_frame->fp = fp;
 215   regcache_cpy (dummy_frame->regcache, current_regcache);
 216   dummy_frame->next = dummy_frame_stack;
 217   dummy_frame_stack = dummy_frame;
 218 }
 219
 220 void
 221 generic_save_dummy_frame_tos (CORE_ADDR sp)
 222 {
 223   dummy_frame_stack->top = sp;
 224 }
 225
 226 /* Record the upper/lower bounds on the address of the call dummy.  */
 227
 228 void
 229 generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi)
 230 {
 231   dummy_frame_stack->call_lo = lo;
 232   dummy_frame_stack->call_hi = hi;
 233 }
 234
 235 /* Restore the machine state from either the saved dummy stack or a
 236    real stack frame. */
 237
 238 void
 239 generic_pop_current_frame (void (*popper) (struct frame_info * frame))
 240 {
 241   struct frame_info *frame = get_current_frame ();
 242
 243   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 244     generic_pop_dummy_frame ();
 245   else
 246     (*popper) (frame);
 247 }
 248
 249 /* Function: pop_dummy_frame
 250    Restore the machine state from a saved dummy stack frame. */
 251
 252 void
 253 generic_pop_dummy_frame (void)
 254 {
 255   struct dummy_frame *dummy_frame = dummy_frame_stack;
 256
 257   /* FIXME: what if the first frame isn't the right one, eg..
 258      because one call-by-hand function has done a longjmp into another one? */
 259
 260   if (!dummy_frame)
 261     error ("Can't pop dummy frame!");
 262   dummy_frame_stack = dummy_frame->next;
 263   regcache_cpy (current_regcache, dummy_frame->regcache);
 264   flush_cached_frames ();
 265
 266   regcache_xfree (dummy_frame->regcache);
 267   xfree (dummy_frame);
 268 }
 269
 270 /* Function: fix_call_dummy
 271    Stub function.  Generic dummy frames typically do not need to fix
 272    the frame being created */
 273
 274 void
 275 generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 276                         struct value **args, struct type *type, int gcc_p)
 277 {
 278   return;
 279 }
 280
 281 /* Given a call-dummy dummy-frame, return the registers.  Here the
 282    register value is taken from the local copy of the register buffer.  */
 283
 284 void
 285 dummy_frame_register_unwind (struct frame_info *frame, void **cache,
 286                              int regnum, int *optimized,
 287                              enum lval_type *lvalp, CORE_ADDR *addrp,
 288                              int *realnum, void *bufferp)
 289 {
 290   struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache);
 291   gdb_assert (dummy != NULL);
 292
 293   /* Describe the register's location.  Generic dummy frames always
 294      have the register value in an ``expression''.  */
 295   *optimized = 0;
 296   *lvalp = not_lval;
 297   *addrp = 0;
 298   *realnum = -1;
 299
 300   /* If needed, find and return the value of the register.  */
 301   if (bufferp != NULL)
 302     {
 303       /* Return the actual value.  */
 304       /* Use the regcache_cooked_read() method so that it, on the fly,
 305          constructs either a raw or pseudo register from the raw
 306          register cache.  */
 307       regcache_cooked_read (dummy->regcache, regnum, bufferp);
 308     }
 309 }
 310