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