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