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
  35 static void dummy_frame_this_id (struct frame_info *next_frame,
  36                                  void **this_prologue_cache,
  37                                  struct frame_id *this_id);
  38
  39 static int pc_in_dummy_frame (CORE_ADDR pc);
  40
  41 /* Dummy frame.  This saves the processor state just prior to setting
  42    up the inferior function call.  Older targets save the registers
  43    on the target stack (but that really slows down function calls).  */
  44
  45 struct dummy_frame
  46 {
  47   struct dummy_frame *next;
  48
  49   /* These values belong to the caller (the previous frame, the frame
  50      that this unwinds back to).  */
  51   CORE_ADDR pc;
  52   CORE_ADDR fp;
  53   CORE_ADDR sp;
  54   CORE_ADDR top;
  55   struct frame_id id;
  56   struct regcache *regcache;
  57
  58   /* Address range of the call dummy code.  Look for PC in the range
  59      [LO..HI) (after allowing for DECR_PC_AFTER_BREAK).  */
  60   CORE_ADDR call_lo;
  61   CORE_ADDR call_hi;
  62 };
  63
  64 static struct dummy_frame *dummy_frame_stack = NULL;
  65
  66 /* Function: find_dummy_frame(pc, fp, sp)
  67
  68    Search the stack of dummy frames for one matching the given PC and
  69    FP/SP.  Unlike pc_in_dummy_frame(), this function doesn't need to
  70    adjust for DECR_PC_AFTER_BREAK.  This is because it is only legal
  71    to call this function after the PC has been adjusted.  */
  72
  73 static struct dummy_frame *
  74 find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
  75 {
  76   struct dummy_frame *dummyframe;
  77
  78   for (dummyframe = dummy_frame_stack; dummyframe != NULL;
  79        dummyframe = dummyframe->next)
  80     {
  81       /* Does the PC fall within the dummy frame's breakpoint
  82          instruction.  If not, discard this one.  */
  83       if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi))
  84         continue;
  85       /* Does the FP match?  */
  86       if (dummyframe->top != 0)
  87         {
  88           /* If the target architecture explicitly saved the
  89              top-of-stack before the inferior function call, assume
  90              that that same architecture will always pass in an FP
  91              (frame base) value that eactly matches that saved TOS.
  92              Don't check the saved SP and SP as they can lead to false
  93              hits.  */
  94           if (fp != dummyframe->top)
  95             continue;
  96         }
  97       else
  98         {
  99           /* An older target that hasn't explicitly or implicitly
 100              saved the dummy frame's top-of-stack.  Try matching the
 101              FP against the saved SP and FP.  NOTE: If you're trying
 102              to fix a problem with GDB not correctly finding a dummy
 103              frame, check the comments that go with FRAME_ALIGN() and
 104              UNWIND_DUMMY_ID().  */
 105           if (fp != dummyframe->fp && fp != dummyframe->sp)
 106             continue;
 107         }
 108       /* The FP matches this dummy frame.  */
 109       return dummyframe;
 110     }
 111
 112   return NULL;
 113 }
 114
 115 static struct regcache *
 116 deprecated_find_dummy_frame_regcache (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 = deprecated_find_dummy_frame_regcache (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 deprecated_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.  */
 155
 156 static int
 157 pc_in_dummy_frame (CORE_ADDR pc)
 158 {
 159   struct dummy_frame *dummyframe;
 160   for (dummyframe = dummy_frame_stack;
 161        dummyframe != NULL;
 162        dummyframe = dummyframe->next)
 163     {
 164       if ((pc >= dummyframe->call_lo)
 165           && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
 166         return 1;
 167     }
 168   return 0;
 169 }
 170
 171 /* Function: read_register_dummy
 172    Find a saved register from before GDB calls a function in the inferior */
 173
 174 CORE_ADDR
 175 deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
 176 {
 177   struct regcache *dummy_regs = deprecated_find_dummy_frame_regcache (pc, fp);
 178
 179   if (dummy_regs)
 180     {
 181       /* NOTE: cagney/2002-08-12: Replaced a call to
 182          regcache_raw_read_as_address() with a call to
 183          regcache_cooked_read_unsigned().  The old, ...as_address
 184          function was eventually calling extract_unsigned_integer (nee
 185          extract_address) to unpack the registers value.  The below is
 186          doing an unsigned extract so that it is functionally
 187          equivalent.  The read needs to be cooked as, otherwise, it
 188          will never correctly return the value of a register in the
 189          [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range.  */
 190       ULONGEST val;
 191       regcache_cooked_read_unsigned (dummy_regs, regno, &val);
 192       return val;
 193     }
 194   else
 195     return 0;
 196 }
 197
 198 /* Save all the registers on the dummy frame stack.  Most ports save the
 199    registers on the target stack.  This results in lots of unnecessary memory
 200    references, which are slow when debugging via a serial line.  Instead, we
 201    save all the registers internally, and never write them to the stack.  The
 202    registers get restored when the called function returns to the entry point,
 203    where a breakpoint is laying in wait.  */
 204
 205 void
 206 generic_push_dummy_frame (void)
 207 {
 208   struct dummy_frame *dummy_frame;
 209   CORE_ADDR fp = get_frame_base (get_current_frame ());
 210
 211   /* check to see if there are stale dummy frames,
 212      perhaps left over from when a longjump took us out of a
 213      function that was called by the debugger */
 214
 215   dummy_frame = dummy_frame_stack;
 216   while (dummy_frame)
 217     if (INNER_THAN (dummy_frame->fp, fp))       /* stale -- destroy! */
 218       {
 219         dummy_frame_stack = dummy_frame->next;
 220         regcache_xfree (dummy_frame->regcache);
 221         xfree (dummy_frame);
 222         dummy_frame = dummy_frame_stack;
 223       }
 224     else
 225       dummy_frame = dummy_frame->next;
 226
 227   dummy_frame = xmalloc (sizeof (struct dummy_frame));
 228   dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
 229
 230   dummy_frame->pc = read_pc ();
 231   dummy_frame->sp = read_sp ();
 232   dummy_frame->top = 0;
 233   dummy_frame->fp = fp;
 234   dummy_frame->id = get_frame_id (get_current_frame ());
 235   regcache_cpy (dummy_frame->regcache, current_regcache);
 236   dummy_frame->next = dummy_frame_stack;
 237   dummy_frame_stack = dummy_frame;
 238 }
 239
 240 void
 241 generic_save_dummy_frame_tos (CORE_ADDR sp)
 242 {
 243   dummy_frame_stack->top = sp;
 244 }
 245
 246 /* Record the upper/lower bounds on the address of the call dummy.  */
 247
 248 void
 249 generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi)
 250 {
 251   dummy_frame_stack->call_lo = lo;
 252   dummy_frame_stack->call_hi = hi;
 253 }
 254
 255 /* Discard the innermost dummy frame from the dummy frame stack
 256    (passed in as a parameter).  */
 257
 258 static void
 259 discard_innermost_dummy (struct dummy_frame **stack)
 260 {
 261   struct dummy_frame *tbd = (*stack);
 262   (*stack) = (*stack)->next;
 263   regcache_xfree (tbd->regcache);
 264   xfree (tbd);
 265 }
 266
 267 void
 268 deprecated_pop_dummy_frame (void)
 269 {
 270   struct dummy_frame *dummy_frame = dummy_frame_stack;
 271
 272   /* FIXME: what if the first frame isn't the right one, eg..
 273      because one call-by-hand function has done a longjmp into another one? */
 274
 275   if (!dummy_frame)
 276     error ("Can't pop dummy frame!");
 277   regcache_cpy (current_regcache, dummy_frame->regcache);
 278   flush_cached_frames ();
 279
 280   discard_innermost_dummy (&dummy_frame_stack);
 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 static void
 287 dummy_frame_prev_register (struct frame_info *next_frame,
 288                            void **this_prologue_cache,
 289                            int regnum, int *optimized,
 290                            enum lval_type *lvalp, CORE_ADDR *addrp,
 291                            int *realnum, void *bufferp)
 292 {
 293   struct dummy_frame *dummy;
 294   struct frame_id id;
 295
 296   /* Call the ID method which, if at all possible, will set the
 297      prologue cache.  */
 298   dummy_frame_this_id (next_frame, this_prologue_cache, &id);
 299   dummy = (*this_prologue_cache);
 300   gdb_assert (dummy != NULL);
 301
 302   /* Describe the register's location.  Generic dummy frames always
 303      have the register value in an ``expression''.  */
 304   *optimized = 0;
 305   *lvalp = not_lval;
 306   *addrp = 0;
 307   *realnum = -1;
 308
 309   /* If needed, find and return the value of the register.  */
 310   if (bufferp != NULL)
 311     {
 312       /* Return the actual value.  */
 313       /* Use the regcache_cooked_read() method so that it, on the fly,
 314          constructs either a raw or pseudo register from the raw
 315          register cache.  */
 316       regcache_cooked_read (dummy->regcache, regnum, bufferp);
 317     }
 318 }
 319
 320 /* Assuming that THIS frame is a dummy (remember, the NEXT and not
 321    THIS frame is passed in), return the ID of THIS frame.  That ID is
 322    determined by examining the NEXT frame's unwound registers using
 323    the method unwind_dummy_id().  As a side effect, THIS dummy frame's
 324    dummy cache is located and and saved in THIS_PROLOGUE_CACHE.  */
 325
 326 static void
 327 dummy_frame_this_id (struct frame_info *next_frame,
 328                      void **this_prologue_cache,
 329                      struct frame_id *this_id)
 330 {
 331   struct dummy_frame *dummy = (*this_prologue_cache);
 332   if (dummy != NULL)
 333     {
 334       (*this_id) = dummy->id;
 335       return;
 336     }
 337   /* When unwinding a normal frame, the stack structure is determined
 338      by analyzing the frame's function's code (be it using brute force
 339      prologue analysis, or the dwarf2 CFI).  In the case of a dummy
 340      frame, that simply isn't possible.  The The PC is either the
 341      program entry point, or some random address on the stack.  Trying
 342      to use that PC to apply standard frame ID unwind techniques is
 343      just asking for trouble.  */
 344   if (gdbarch_unwind_dummy_id_p (current_gdbarch))
 345     {
 346       /* Use an architecture specific method to extract the prev's
 347          dummy ID from the next frame.  Note that this method uses
 348          frame_register_unwind to obtain the register values needed to
 349          determine the dummy frame's ID.  */
 350       (*this_id) = gdbarch_unwind_dummy_id (current_gdbarch, next_frame);
 351     }
 352   else if (get_frame_type (next_frame) == SENTINEL_FRAME)
 353     {
 354       /* We're unwinding a sentinel frame, the PC of which is pointing
 355          at a stack dummy.  Fake up the dummy frame's ID using the
 356          same sequence as is found a traditional unwinder.  Once all
 357          architectures supply the unwind_dummy_id method, this code
 358          can go away.  */
 359       (*this_id) = frame_id_build (deprecated_read_fp (), read_pc ());
 360     }
 361   else if (legacy_frame_p (current_gdbarch)
 362            && get_prev_frame (next_frame))
 363     {
 364       /* Things are looking seriously grim!  Assume that the legacy
 365          get_prev_frame code has already created THIS frame and linked
 366          it in to the frame chain (a pretty bold assumption), extract
 367          the ID from THIS base / pc.  */
 368       (*this_id) = frame_id_build (get_frame_base (get_prev_frame (next_frame)),
 369                                    get_frame_pc (get_prev_frame (next_frame)));
 370     }
 371   else
 372     {
 373       /* Ouch!  We're not trying to find the innermost frame's ID yet
 374          we're trying to unwind to a dummy.  The architecture must
 375          provide the unwind_dummy_id() method.  Abandon the unwind
 376          process but only after first warning the user.  */
 377       internal_warning (__FILE__, __LINE__,
 378                         "Missing unwind_dummy_id architecture method");
 379       (*this_id) = null_frame_id;
 380       return;
 381     }
 382   (*this_prologue_cache) = find_dummy_frame ((*this_id).code_addr,
 383                                              (*this_id).stack_addr);
 384 }
 385
 386 static struct frame_unwind dummy_frame_unwind =
 387 {
 388   DUMMY_FRAME,
 389   dummy_frame_this_id,
 390   dummy_frame_prev_register
 391 };
 392
 393 const struct frame_unwind *
 394 dummy_frame_sniffer (struct frame_info *next_frame)
 395 {
 396   CORE_ADDR pc = frame_pc_unwind (next_frame);
 397   if (pc_in_dummy_frame (pc))
 398     return &dummy_frame_unwind;
 399   else
 400     return NULL;
 401 }
 402
 403 static void
 404 fprint_dummy_frames (struct ui_file *file)
 405 {
 406   struct dummy_frame *s;
 407   for (s = dummy_frame_stack; s != NULL; s = s->next)
 408     {
 409       gdb_print_host_address (s, file);
 410       fprintf_unfiltered (file, ":");
 411       fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc));
 412       fprintf_unfiltered (file, " fp=0x%s", paddr (s->fp));
 413       fprintf_unfiltered (file, " sp=0x%s", paddr (s->sp));
 414       fprintf_unfiltered (file, " top=0x%s", paddr (s->top));
 415       fprintf_unfiltered (file, " id=");
 416       fprint_frame_id (file, s->id);
 417       fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo));
 418       fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi));
 419       fprintf_unfiltered (file, "\n");
 420     }
 421 }
 422
 423 static void
 424 maintenance_print_dummy_frames (char *args, int from_tty)
 425 {
 426   if (args == NULL)
 427     fprint_dummy_frames (gdb_stdout);
 428   else
 429     {
 430       struct ui_file *file = gdb_fopen (args, "w");
 431       if (file == NULL)
 432         perror_with_name ("maintenance print dummy-frames");
 433       fprint_dummy_frames (file);
 434       ui_file_delete (file);
 435     }
 436 }
 437
 438 extern void _initialize_dummy_frame (void);
 439
 440 void
 441 _initialize_dummy_frame (void)
 442 {
 443   add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
 444            "Print the contents of the internal dummy-frame stack.",
 445            &maintenanceprintlist);
 446
 447 }