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, 2008
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "defs.h"
  24 #include "dummy-frame.h"
  25 #include "regcache.h"
  26 #include "frame.h"
  27 #include "inferior.h"
  28 #include "gdb_assert.h"
  29 #include "frame-unwind.h"
  30 #include "command.h"
  31 #include "gdbcmd.h"
  32 #include "gdb_string.h"
  33 #include "observer.h"
  34
  35 /* Dummy frame.  This saves the processor state just prior to setting
  36    up the inferior function call.  Older targets save the registers
  37    on the target stack (but that really slows down function calls).  */
  38
  39 struct dummy_frame
  40 {
  41   struct dummy_frame *next;
  42   /* This frame's ID.  Must match the value returned by
  43      gdbarch_dummy_id.  */
  44   struct frame_id id;
  45   /* The caller's regcache.  */
  46   struct regcache *regcache;
  47 };
  48
  49 static struct dummy_frame *dummy_frame_stack = NULL;
  50
  51 /* Function: deprecated_pc_in_call_dummy (pc)
  52
  53    Return non-zero if the PC falls in a dummy frame created by gdb for
  54    an inferior call.  The code below which allows gdbarch_decr_pc_after_break
  55    is for infrun.c, which may give the function a PC without that
  56    subtracted out.
  57
  58    FIXME: cagney/2002-11-23: This is silly.  Surely "infrun.c" can
  59    figure out what the real PC (as in the resume address) is BEFORE
  60    calling this function.
  61
  62    NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of
  63    infrun.c:adjust_pc_after_break (thanks), this function is now
  64    always called with a correctly adjusted PC!
  65
  66    NOTE: cagney/2004-08-02: Code should not need to call this.  */
  67
  68 int
  69 deprecated_pc_in_call_dummy (CORE_ADDR pc)
  70 {
  71   struct dummy_frame *dummyframe;
  72   for (dummyframe = dummy_frame_stack;
  73        dummyframe != NULL;
  74        dummyframe = dummyframe->next)
  75     {
  76       if ((pc >= dummyframe->id.code_addr)
  77           && (pc <= dummyframe->id.code_addr
  78                     + gdbarch_decr_pc_after_break (current_gdbarch)))
  79         return 1;
  80     }
  81   return 0;
  82 }
  83
  84 /* Push the caller's state, along with the dummy frame info, onto a
  85    dummy-frame stack.  */
  86
  87 void
  88 dummy_frame_push (struct regcache *caller_regcache,
  89                   const struct frame_id *dummy_id)
  90 {
  91   struct dummy_frame *dummy_frame;
  92
  93   dummy_frame = XZALLOC (struct dummy_frame);
  94   dummy_frame->regcache = caller_regcache;
  95   dummy_frame->id = (*dummy_id);
  96   dummy_frame->next = dummy_frame_stack;
  97   dummy_frame_stack = dummy_frame;
  98 }
  99
 100 /* Pop the dummy frame with ID dummy_id from the dummy-frame stack.  */
 101
 102 void
 103 dummy_frame_pop (struct frame_id dummy_id)
 104 {
 105   struct dummy_frame **dummy_ptr;
 106
 107   for (dummy_ptr = &dummy_frame_stack;
 108        (*dummy_ptr) != NULL;
 109        dummy_ptr = &(*dummy_ptr)->next)
 110     {
 111       struct dummy_frame *dummy = *dummy_ptr;
 112       if (frame_id_eq (dummy->id, dummy_id))
 113         {
 114           *dummy_ptr = dummy->next;
 115           regcache_xfree (dummy->regcache);
 116           xfree (dummy);
 117           break;
 118         }
 119     }
 120 }
 121
 122 /* There may be stale dummy frames, perhaps left over from when a longjump took us
 123    out of a function that was called by the debugger.  Clean them up at least once
 124    whenever we start a new inferior.  */
 125
 126 static void
 127 cleanup_dummy_frames (struct target_ops *target, int from_tty)
 128 {
 129   struct dummy_frame *dummy, *next;
 130
 131   for (dummy = dummy_frame_stack; dummy; dummy = next)
 132     {
 133       next = dummy->next;
 134       regcache_xfree (dummy->regcache);
 135       xfree (dummy);
 136     }
 137
 138   dummy_frame_stack = NULL;
 139 }
 140
 141 /* Return the dummy frame cache, it contains both the ID, and a
 142    pointer to the regcache.  */
 143 struct dummy_frame_cache
 144 {
 145   struct frame_id this_id;
 146   struct regcache *prev_regcache;
 147 };
 148
 149 int
 150 dummy_frame_sniffer (const struct frame_unwind *self,
 151                      struct frame_info *this_frame,
 152                      void **this_prologue_cache)
 153 {
 154   struct dummy_frame *dummyframe;
 155   struct frame_id this_id;
 156
 157   /* When unwinding a normal frame, the stack structure is determined
 158      by analyzing the frame's function's code (be it using brute force
 159      prologue analysis, or the dwarf2 CFI).  In the case of a dummy
 160      frame, that simply isn't possible.  The PC is either the program
 161      entry point, or some random address on the stack.  Trying to use
 162      that PC to apply standard frame ID unwind techniques is just
 163      asking for trouble.  */
 164
 165   /* Don't bother unles there is at least one dummy frame.  */
 166   if (dummy_frame_stack != NULL)
 167     {
 168       /* Use an architecture specific method to extract this frame's
 169          dummy ID, assuming it is a dummy frame.  */
 170       this_id = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
 171
 172       /* Use that ID to find the corresponding cache entry.  */
 173       for (dummyframe = dummy_frame_stack;
 174            dummyframe != NULL;
 175            dummyframe = dummyframe->next)
 176         {
 177           if (frame_id_eq (dummyframe->id, this_id))
 178             {
 179               struct dummy_frame_cache *cache;
 180               cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
 181               cache->prev_regcache = dummyframe->regcache;
 182               cache->this_id = this_id;
 183               (*this_prologue_cache) = cache;
 184               return 1;
 185             }
 186         }
 187     }
 188   return 0;
 189 }
 190
 191 /* Given a call-dummy dummy-frame, return the registers.  Here the
 192    register value is taken from the local copy of the register buffer.  */
 193
 194 static struct value *
 195 dummy_frame_prev_register (struct frame_info *this_frame,
 196                            void **this_prologue_cache,
 197                            int regnum)
 198 {
 199   struct dummy_frame_cache *cache = (*this_prologue_cache);
 200   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 201   struct value *reg_val;
 202
 203   /* The dummy-frame sniffer always fills in the cache.  */
 204   gdb_assert (cache != NULL);
 205
 206   /* Describe the register's location.  Generic dummy frames always
 207      have the register value in an ``expression''.  */
 208   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 209
 210   /* Use the regcache_cooked_read() method so that it, on the fly,
 211      constructs either a raw or pseudo register from the raw
 212      register cache.  */
 213   regcache_cooked_read (cache->prev_regcache, regnum,
 214                         value_contents_writeable (reg_val));
 215   return reg_val;
 216 }
 217
 218 /* Assuming that THIS frame is a dummy, return the ID of THIS frame.  That ID is
 219    determined by examining the NEXT frame's unwound registers using
 220    the method dummy_id().  As a side effect, THIS dummy frame's
 221    dummy cache is located and and saved in THIS_PROLOGUE_CACHE.  */
 222
 223 static void
 224 dummy_frame_this_id (struct frame_info *this_frame,
 225                      void **this_prologue_cache,
 226                      struct frame_id *this_id)
 227 {
 228   /* The dummy-frame sniffer always fills in the cache.  */
 229   struct dummy_frame_cache *cache = (*this_prologue_cache);
 230   gdb_assert (cache != NULL);
 231   (*this_id) = cache->this_id;
 232 }
 233
 234 static const struct frame_unwind dummy_frame_unwinder =
 235 {
 236   DUMMY_FRAME,
 237   dummy_frame_this_id,
 238   dummy_frame_prev_register,
 239   NULL,
 240   dummy_frame_sniffer,
 241 };
 242
 243 const struct frame_unwind *const dummy_frame_unwind = {
 244   &dummy_frame_unwinder
 245 };
 246
 247 static void
 248 fprint_dummy_frames (struct ui_file *file)
 249 {
 250   struct dummy_frame *s;
 251   for (s = dummy_frame_stack; s != NULL; s = s->next)
 252     {
 253       gdb_print_host_address (s, file);
 254       fprintf_unfiltered (file, ":");
 255       fprintf_unfiltered (file, " id=");
 256       fprint_frame_id (file, s->id);
 257       fprintf_unfiltered (file, "\n");
 258     }
 259 }
 260
 261 static void
 262 maintenance_print_dummy_frames (char *args, int from_tty)
 263 {
 264   if (args == NULL)
 265     fprint_dummy_frames (gdb_stdout);
 266   else
 267     {
 268       struct cleanup *cleanups;
 269       struct ui_file *file = gdb_fopen (args, "w");
 270       if (file == NULL)
 271         perror_with_name (_("maintenance print dummy-frames"));
 272       cleanups = make_cleanup_ui_file_delete (file);
 273       fprint_dummy_frames (file);
 274       do_cleanups (cleanups);
 275     }
 276 }
 277
 278 extern void _initialize_dummy_frame (void);
 279
 280 void
 281 _initialize_dummy_frame (void)
 282 {
 283   add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
 284            _("Print the contents of the internal dummy-frame stack."),
 285            &maintenanceprintlist);
 286
 287   observer_attach_inferior_created (cleanup_dummy_frames);
 288 }