gdb/dummy-frame.c

   1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "defs.h"
  22 #include "dummy-frame.h"
  23 #include "regcache.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "gdb_assert.h"
  27 #include "frame-unwind.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30 #include "gdb_string.h"
  31 #include "observer.h"
  32 #include "gdbthread.h"
  33
  34 /* Dummy frame.  This saves the processor state just prior to setting
  35    up the inferior function call.  Older targets save the registers
  36    on the target stack (but that really slows down function calls).  */
  37
  38 struct dummy_frame
  39 {
  40   struct dummy_frame *next;
  41   /* This frame's ID.  Must match the value returned by
  42      gdbarch_dummy_id.  */
  43   struct frame_id id;
  44   /* The caller's state prior to the call.  */
  45   struct infcall_suspend_state *caller_state;
  46 };
  47
  48 static struct dummy_frame *dummy_frame_stack = NULL;
  49
  50 /* Function: deprecated_pc_in_call_dummy (pc)
  51
  52    Return non-zero if the PC falls in a dummy frame created by gdb for
  53    an inferior call.  The code below which allows gdbarch_decr_pc_after_break
  54    is for infrun.c, which may give the function a PC without that
  55    subtracted out.
  56
  57    FIXME: cagney/2002-11-23: This is silly.  Surely "infrun.c" can
  58    figure out what the real PC (as in the resume address) is BEFORE
  59    calling this function.
  60
  61    NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of
  62    infrun.c:adjust_pc_after_break (thanks), this function is now
  63    always called with a correctly adjusted PC!
  64
  65    NOTE: cagney/2004-08-02: Code should not need to call this.  */
  66
  67 int
  68 deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc)
  69 {
  70   struct dummy_frame *dummyframe;
  71
  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 (gdbarch)))
  79         return 1;
  80     }
  81   return 0;
  82 }
  83
  84 /* Push the caller's state, along with the dummy frame info, onto the
  85    dummy-frame stack.  */
  86
  87 void
  88 dummy_frame_push (struct infcall_suspend_state *caller_state,
  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->caller_state = caller_state;
  95   dummy_frame->id = (*dummy_id);
  96   dummy_frame->next = dummy_frame_stack;
  97   dummy_frame_stack = dummy_frame;
  98 }
  99
 100 /* Remove *DUMMY_PTR from the dummy frame stack.  */
 101
 102 static void
 103 remove_dummy_frame (struct dummy_frame **dummy_ptr)
 104 {
 105   struct dummy_frame *dummy = *dummy_ptr;
 106
 107   *dummy_ptr = dummy->next;
 108   discard_infcall_suspend_state (dummy->caller_state);
 109   xfree (dummy);
 110 }
 111
 112 /* Delete any breakpoint B which is a momentary breakpoint for return from
 113    inferior call matching DUMMY_VOIDP.  */
 114
 115 static int
 116 pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
 117 {
 118   struct dummy_frame *dummy = dummy_voidp;
 119
 120   if (b->thread == pid_to_thread_id (inferior_ptid)
 121       && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id))
 122     {
 123       while (b->related_breakpoint != b)
 124         delete_breakpoint (b->related_breakpoint);
 125
 126       delete_breakpoint (b);
 127
 128       /* Stop the traversal.  */
 129       return 1;
 130     }
 131
 132   /* Continue the traversal.  */
 133   return 0;
 134 }
 135
 136 /* Pop *DUMMY_PTR, restoring program state to that before the
 137    frame was created.  */
 138
 139 static void
 140 pop_dummy_frame (struct dummy_frame **dummy_ptr)
 141 {
 142   struct dummy_frame *dummy = *dummy_ptr;
 143
 144   restore_infcall_suspend_state (dummy->caller_state);
 145
 146   iterate_over_breakpoints (pop_dummy_frame_bpt, dummy);
 147
 148   /* restore_infcall_control_state frees inf_state,
 149      all that remains is to pop *dummy_ptr.  */
 150   *dummy_ptr = dummy->next;
 151   xfree (dummy);
 152
 153   /* We've made right mess of GDB's local state, just discard
 154      everything.  */
 155   reinit_frame_cache ();
 156 }
 157
 158 /* Look up DUMMY_ID.
 159    Return NULL if not found.  */
 160
 161 static struct dummy_frame **
 162 lookup_dummy_frame (struct frame_id dummy_id)
 163 {
 164   struct dummy_frame **dp;
 165
 166   for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
 167     {
 168       if (frame_id_eq ((*dp)->id, dummy_id))
 169         return dp;
 170     }
 171
 172   return NULL;
 173 }
 174
 175 /* Pop the dummy frame DUMMY_ID, restoring program state to that before the
 176    frame was created.
 177    On return reinit_frame_cache has been called.
 178    If the frame isn't found, flag an internal error.
 179
 180    NOTE: This can only pop the one frame, even if it is in the middle of the
 181    stack, because the other frames may be for different threads, and there's
 182    currently no way to tell which stack frame is for which thread.  */
 183
 184 void
 185 dummy_frame_pop (struct frame_id dummy_id)
 186 {
 187   struct dummy_frame **dp;
 188
 189   dp = lookup_dummy_frame (dummy_id);
 190   gdb_assert (dp != NULL);
 191
 192   pop_dummy_frame (dp);
 193 }
 194
 195 /* Drop dummy frame DUMMY_ID.  Do nothing if it is not found.  Do not restore
 196    its state into inferior, just free its memory.  */
 197
 198 void
 199 dummy_frame_discard (struct frame_id dummy_id)
 200 {
 201   struct dummy_frame **dp;
 202
 203   dp = lookup_dummy_frame (dummy_id);
 204   if (dp)
 205     remove_dummy_frame (dp);
 206 }
 207
 208 /* There may be stale dummy frames, perhaps left over from when an uncaught
 209    longjmp took us out of a function that was called by the debugger.  Clean
 210    them up at least once whenever we start a new inferior.  */
 211
 212 static void
 213 cleanup_dummy_frames (struct target_ops *target, int from_tty)
 214 {
 215   while (dummy_frame_stack != NULL)
 216     remove_dummy_frame (&dummy_frame_stack);
 217 }
 218
 219 /* Return the dummy frame cache, it contains both the ID, and a
 220    pointer to the regcache.  */
 221 struct dummy_frame_cache
 222 {
 223   struct frame_id this_id;
 224   struct regcache *prev_regcache;
 225 };
 226
 227 static int
 228 dummy_frame_sniffer (const struct frame_unwind *self,
 229                      struct frame_info *this_frame,
 230                      void **this_prologue_cache)
 231 {
 232   struct dummy_frame *dummyframe;
 233   struct frame_id this_id;
 234
 235   /* When unwinding a normal frame, the stack structure is determined
 236      by analyzing the frame's function's code (be it using brute force
 237      prologue analysis, or the dwarf2 CFI).  In the case of a dummy
 238      frame, that simply isn't possible.  The PC is either the program
 239      entry point, or some random address on the stack.  Trying to use
 240      that PC to apply standard frame ID unwind techniques is just
 241      asking for trouble.  */
 242
 243   /* Don't bother unless there is at least one dummy frame.  */
 244   if (dummy_frame_stack != NULL)
 245     {
 246       /* Use an architecture specific method to extract this frame's
 247          dummy ID, assuming it is a dummy frame.  */
 248       this_id = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
 249
 250       /* Use that ID to find the corresponding cache entry.  */
 251       for (dummyframe = dummy_frame_stack;
 252            dummyframe != NULL;
 253            dummyframe = dummyframe->next)
 254         {
 255           if (frame_id_eq (dummyframe->id, this_id))
 256             {
 257               struct dummy_frame_cache *cache;
 258
 259               cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
 260               cache->prev_regcache = get_infcall_suspend_state_regcache
 261                                                    (dummyframe->caller_state);
 262               cache->this_id = this_id;
 263               (*this_prologue_cache) = cache;
 264               return 1;
 265             }
 266         }
 267     }
 268   return 0;
 269 }
 270
 271 /* Given a call-dummy dummy-frame, return the registers.  Here the
 272    register value is taken from the local copy of the register buffer.  */
 273
 274 static struct value *
 275 dummy_frame_prev_register (struct frame_info *this_frame,
 276                            void **this_prologue_cache,
 277                            int regnum)
 278 {
 279   struct dummy_frame_cache *cache = (*this_prologue_cache);
 280   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 281   struct value *reg_val;
 282
 283   /* The dummy-frame sniffer always fills in the cache.  */
 284   gdb_assert (cache != NULL);
 285
 286   /* Describe the register's location.  Generic dummy frames always
 287      have the register value in an ``expression''.  */
 288   reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
 289
 290   /* Use the regcache_cooked_read() method so that it, on the fly,
 291      constructs either a raw or pseudo register from the raw
 292      register cache.  */
 293   regcache_cooked_read (cache->prev_regcache, regnum,
 294                         value_contents_writeable (reg_val));
 295   return reg_val;
 296 }
 297
 298 /* Assuming that THIS_FRAME is a dummy, return its ID.  That ID is
 299    determined by examining the NEXT frame's unwound registers using
 300    the method dummy_id().  As a side effect, THIS dummy frame's
 301    dummy cache is located and saved in THIS_PROLOGUE_CACHE.  */
 302
 303 static void
 304 dummy_frame_this_id (struct frame_info *this_frame,
 305                      void **this_prologue_cache,
 306                      struct frame_id *this_id)
 307 {
 308   /* The dummy-frame sniffer always fills in the cache.  */
 309   struct dummy_frame_cache *cache = (*this_prologue_cache);
 310
 311   gdb_assert (cache != NULL);
 312   (*this_id) = cache->this_id;
 313 }
 314
 315 const struct frame_unwind dummy_frame_unwind =
 316 {
 317   DUMMY_FRAME,
 318   default_frame_unwind_stop_reason,
 319   dummy_frame_this_id,
 320   dummy_frame_prev_register,
 321   NULL,
 322   dummy_frame_sniffer,
 323 };
 324
 325 static void
 326 fprint_dummy_frames (struct ui_file *file)
 327 {
 328   struct dummy_frame *s;
 329
 330   for (s = dummy_frame_stack; s != NULL; s = s->next)
 331     {
 332       gdb_print_host_address (s, file);
 333       fprintf_unfiltered (file, ":");
 334       fprintf_unfiltered (file, " id=");
 335       fprint_frame_id (file, s->id);
 336       fprintf_unfiltered (file, "\n");
 337     }
 338 }
 339
 340 static void
 341 maintenance_print_dummy_frames (char *args, int from_tty)
 342 {
 343   if (args == NULL)
 344     fprint_dummy_frames (gdb_stdout);
 345   else
 346     {
 347       struct cleanup *cleanups;
 348       struct ui_file *file = gdb_fopen (args, "w");
 349
 350       if (file == NULL)
 351         perror_with_name (_("maintenance print dummy-frames"));
 352       cleanups = make_cleanup_ui_file_delete (file);
 353       fprint_dummy_frames (file);
 354       do_cleanups (cleanups);
 355     }
 356 }
 357
 358 extern void _initialize_dummy_frame (void);
 359
 360 void
 361 _initialize_dummy_frame (void)
 362 {
 363   add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
 364            _("Print the contents of the internal dummy-frame stack."),
 365            &maintenanceprintlist);
 366
 367   observer_attach_inferior_created (cleanup_dummy_frames);
 368 }