gdb/dummy-frame.c

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