X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdummy-frame.c;h=3b76d456b7b134b5d524263898278ca98ff0b380;hb=aa989b27d0bad451455416953c0e5026e229863a;hp=d6a7241369fed3a6e654ec32a1518c9997445e80;hpb=9a619af0d3152e742fbd290baeae96a32f0abf04;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c
index d6a7241369..3b76d456b7 100644
--- a/gdb/dummy-frame.c
+++ b/gdb/dummy-frame.c
@@ -1,8 +1,6 @@
 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
 
-   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
-   2010 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -25,75 +23,81 @@
 #include "regcache.h"
 #include "frame.h"
 #include "inferior.h"
-#include "gdb_assert.h"
 #include "frame-unwind.h"
 #include "command.h"
 #include "gdbcmd.h"
-#include "gdb_string.h"
-#include "observer.h"
+#include "observable.h"
+#include "gdbthread.h"
+#include "infcall.h"
+#include "gdbarch.h"
 
-/* Dummy frame.  This saves the processor state just prior to setting
-   up the inferior function call.  Older targets save the registers
-   on the target stack (but that really slows down function calls).  */
-
-struct dummy_frame
+struct dummy_frame_id
 {
-  struct dummy_frame *next;
   /* This frame's ID.  Must match the value returned by
      gdbarch_dummy_id.  */
   struct frame_id id;
-  /* The caller's state prior to the call.  */
-  struct inferior_thread_state *caller_state;
+
+  /* The thread this dummy_frame relates to.  */
+  thread_info *thread;
 };
 
-static struct dummy_frame *dummy_frame_stack = NULL;
+/* Return whether dummy_frame_id *ID1 and *ID2 are equal.  */
+
+static int
+dummy_frame_id_eq (struct dummy_frame_id *id1,
+		   struct dummy_frame_id *id2)
+{
+  return frame_id_eq (id1->id, id2->id) && id1->thread == id2->thread;
+}
 
-/* Function: deprecated_pc_in_call_dummy (pc)
+/* List of dummy_frame destructors.  */
 
-   Return non-zero if the PC falls in a dummy frame created by gdb for
-   an inferior call.  The code below which allows gdbarch_decr_pc_after_break
-   is for infrun.c, which may give the function a PC without that
-   subtracted out.
+struct dummy_frame_dtor_list
+{
+  /* Next element in the list or NULL if this is the last element.  */
+  struct dummy_frame_dtor_list *next;
 
-   FIXME: cagney/2002-11-23: This is silly.  Surely "infrun.c" can
-   figure out what the real PC (as in the resume address) is BEFORE
-   calling this function.
+  /* If non-NULL, a destructor that is run when this dummy frame is freed.  */
+  dummy_frame_dtor_ftype *dtor;
 
-   NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of
-   infrun.c:adjust_pc_after_break (thanks), this function is now
-   always called with a correctly adjusted PC!
+  /* Arbitrary data that is passed to DTOR.  */
+  void *dtor_data;
+};
 
-   NOTE: cagney/2004-08-02: Code should not need to call this.  */
+/* Dummy frame.  This saves the processor state just prior to setting
+   up the inferior function call.  Older targets save the registers
+   on the target stack (but that really slows down function calls).  */
 
-int
-deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc)
+struct dummy_frame
 {
-  struct dummy_frame *dummyframe;
+  struct dummy_frame *next;
 
-  for (dummyframe = dummy_frame_stack;
-       dummyframe != NULL;
-       dummyframe = dummyframe->next)
-    {
-      if ((pc >= dummyframe->id.code_addr)
-	  && (pc <= dummyframe->id.code_addr
-		    + gdbarch_decr_pc_after_break (gdbarch)))
-	return 1;
-    }
-  return 0;
-}
+  /* An id represents a dummy frame.  */
+  struct dummy_frame_id id;
+
+  /* The caller's state prior to the call.  */
+  struct infcall_suspend_state *caller_state;
+
+  /* First element of destructors list or NULL if there are no
+     destructors registered for this dummy_frame.  */
+  struct dummy_frame_dtor_list *dtor_list;
+};
+
+static struct dummy_frame *dummy_frame_stack = NULL;
 
 /* Push the caller's state, along with the dummy frame info, onto the
    dummy-frame stack.  */
 
 void
-dummy_frame_push (struct inferior_thread_state *caller_state,
-		  const struct frame_id *dummy_id)
+dummy_frame_push (struct infcall_suspend_state *caller_state,
+		  const frame_id *dummy_id, thread_info *thread)
 {
   struct dummy_frame *dummy_frame;
 
-  dummy_frame = XZALLOC (struct dummy_frame);
+  dummy_frame = XCNEW (struct dummy_frame);
   dummy_frame->caller_state = caller_state;
-  dummy_frame->id = (*dummy_id);
+  dummy_frame->id.id = (*dummy_id);
+  dummy_frame->id.thread = thread;
   dummy_frame->next = dummy_frame_stack;
   dummy_frame_stack = dummy_frame;
 }
@@ -105,24 +109,70 @@ remove_dummy_frame (struct dummy_frame **dummy_ptr)
 {
   struct dummy_frame *dummy = *dummy_ptr;
 
+  while (dummy->dtor_list != NULL)
+    {
+      struct dummy_frame_dtor_list *list = dummy->dtor_list;
+
+      dummy->dtor_list = list->next;
+      list->dtor (list->dtor_data, 0);
+      xfree (list);
+    }
+
   *dummy_ptr = dummy->next;
-  discard_inferior_thread_state (dummy->caller_state);
+  discard_infcall_suspend_state (dummy->caller_state);
   xfree (dummy);
 }
 
+/* Delete any breakpoint B which is a momentary breakpoint for return from
+   inferior call matching DUMMY_VOIDP.  */
+
+static bool
+pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy)
+{
+  if (b->thread == dummy->id.thread->global_num
+      && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
+    {
+      while (b->related_breakpoint != b)
+	delete_breakpoint (b->related_breakpoint);
+
+      delete_breakpoint (b);
+
+      /* Stop the traversal.  */
+      return true;
+    }
+
+  /* Continue the traversal.  */
+  return false;
+}
+
 /* Pop *DUMMY_PTR, restoring program state to that before the
    frame was created.  */
 
 static void
 pop_dummy_frame (struct dummy_frame **dummy_ptr)
 {
-  struct dummy_frame *dummy;
+  struct dummy_frame *dummy = *dummy_ptr;
+
+  gdb_assert (dummy->id.thread == inferior_thread ());
 
-  restore_inferior_thread_state ((*dummy_ptr)->caller_state);
+  while (dummy->dtor_list != NULL)
+    {
+      struct dummy_frame_dtor_list *list = dummy->dtor_list;
+
+      dummy->dtor_list = list->next;
+      list->dtor (list->dtor_data, 1);
+      xfree (list);
+    }
 
-  /* restore_inferior_status frees inf_state,
-     all that remains is to pop *dummy_ptr */
-  dummy = *dummy_ptr;
+  restore_infcall_suspend_state (dummy->caller_state);
+
+  iterate_over_breakpoints ([dummy] (breakpoint* bp)
+    {
+      return pop_dummy_frame_bpt (bp, dummy);
+    });
+
+  /* restore_infcall_control_state frees inf_state,
+     all that remains is to pop *dummy_ptr.  */
   *dummy_ptr = dummy->next;
   xfree (dummy);
 
@@ -135,42 +185,92 @@ pop_dummy_frame (struct dummy_frame **dummy_ptr)
    Return NULL if not found.  */
 
 static struct dummy_frame **
-lookup_dummy_frame (struct frame_id dummy_id)
+lookup_dummy_frame (struct dummy_frame_id *dummy_id)
 {
   struct dummy_frame **dp;
 
   for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
     {
-      if (frame_id_eq ((*dp)->id, dummy_id))
+      if (dummy_frame_id_eq (&(*dp)->id, dummy_id))
 	return dp;
     }
 
   return NULL;
 }
 
-/* Pop the dummy frame DUMMY_ID, restoring program state to that before the
-   frame was created.
+/* Find the dummy frame by DUMMY_ID and THREAD, and pop it, restoring
+   program state to that before the frame was created.
    On return reinit_frame_cache has been called.
-   If the frame isn't found, flag an internal error.
-
-   NOTE: This can only pop the one frame, even if it is in the middle of the
-   stack, because the other frames may be for different threads, and there's
-   currently no way to tell which stack frame is for which thread.  */
+   If the frame isn't found, flag an internal error.  */
 
 void
-dummy_frame_pop (struct frame_id dummy_id)
+dummy_frame_pop (frame_id dummy_id, thread_info *thread)
 {
   struct dummy_frame **dp;
+  struct dummy_frame_id id = { dummy_id, thread };
 
-  dp = lookup_dummy_frame (dummy_id);
+  dp = lookup_dummy_frame (&id);
   gdb_assert (dp != NULL);
 
   pop_dummy_frame (dp);
 }
 
-/* There may be stale dummy frames, perhaps left over from when a longjump took
-   us out of a function that was called by the debugger.  Clean them up at
-   least once whenever we start a new inferior.  */
+/* Find the dummy frame by DUMMY_ID and PTID and drop it.  Do nothing
+   if it is not found.  Do not restore its state into inferior, just
+   free its memory.  */
+
+void
+dummy_frame_discard (struct frame_id dummy_id, thread_info *thread)
+{
+  struct dummy_frame **dp;
+  struct dummy_frame_id id = { dummy_id, thread };
+
+  dp = lookup_dummy_frame (&id);
+  if (dp)
+    remove_dummy_frame (dp);
+}
+
+/* See dummy-frame.h.  */
+
+void
+register_dummy_frame_dtor (frame_id dummy_id, thread_info *thread,
+			   dummy_frame_dtor_ftype *dtor, void *dtor_data)
+{
+  struct dummy_frame_id id = { dummy_id, thread };
+  struct dummy_frame **dp, *d;
+  struct dummy_frame_dtor_list *list;
+
+  dp = lookup_dummy_frame (&id);
+  gdb_assert (dp != NULL);
+  d = *dp;
+  list = XNEW (struct dummy_frame_dtor_list);
+  list->next = d->dtor_list;
+  d->dtor_list = list;
+  list->dtor = dtor;
+  list->dtor_data = dtor_data;
+}
+
+/* See dummy-frame.h.  */
+
+int
+find_dummy_frame_dtor (dummy_frame_dtor_ftype *dtor, void *dtor_data)
+{
+  struct dummy_frame *d;
+
+  for (d = dummy_frame_stack; d != NULL; d = d->next)
+    {
+      struct dummy_frame_dtor_list *list;
+
+      for (list = d->dtor_list; list != NULL; list = list->next)
+	if (list->dtor == dtor && list->dtor_data == dtor_data)
+	  return 1;
+    }
+  return 0;
+}
+
+/* There may be stale dummy frames, perhaps left over from when an uncaught
+   longjmp took us out of a function that was called by the debugger.  Clean
+   them up at least once whenever we start a new inferior.  */
 
 static void
 cleanup_dummy_frames (struct target_ops *target, int from_tty)
@@ -184,7 +284,7 @@ cleanup_dummy_frames (struct target_ops *target, int from_tty)
 struct dummy_frame_cache
 {
   struct frame_id this_id;
-  struct regcache *prev_regcache;
+  readonly_detached_regcache *prev_regcache;
 };
 
 static int
@@ -192,9 +292,6 @@ dummy_frame_sniffer (const struct frame_unwind *self,
 		     struct frame_info *this_frame,
 		     void **this_prologue_cache)
 {
-  struct dummy_frame *dummyframe;
-  struct frame_id this_id;
-
   /* When unwinding a normal frame, the stack structure is determined
      by analyzing the frame's function's code (be it using brute force
      prologue analysis, or the dwarf2 CFI).  In the case of a dummy
@@ -206,21 +303,25 @@ dummy_frame_sniffer (const struct frame_unwind *self,
   /* Don't bother unless there is at least one dummy frame.  */
   if (dummy_frame_stack != NULL)
     {
+      struct dummy_frame *dummyframe;
       /* Use an architecture specific method to extract this frame's
 	 dummy ID, assuming it is a dummy frame.  */
-      this_id = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
+      struct frame_id this_id
+	= gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
+      struct dummy_frame_id dummy_id = { this_id, inferior_thread () };
 
       /* Use that ID to find the corresponding cache entry.  */
       for (dummyframe = dummy_frame_stack;
 	   dummyframe != NULL;
 	   dummyframe = dummyframe->next)
 	{
-	  if (frame_id_eq (dummyframe->id, this_id))
+	  if (dummy_frame_id_eq (&dummyframe->id, &dummy_id))
 	    {
 	      struct dummy_frame_cache *cache;
 
 	      cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
-	      cache->prev_regcache = get_inferior_thread_state_regcache (dummyframe->caller_state);
+	      cache->prev_regcache = get_infcall_suspend_state_regcache
+						   (dummyframe->caller_state);
 	      cache->this_id = this_id;
 	      (*this_prologue_cache) = cache;
 	      return 1;
@@ -238,7 +339,8 @@ dummy_frame_prev_register (struct frame_info *this_frame,
 			   void **this_prologue_cache,
 			   int regnum)
 {
-  struct dummy_frame_cache *cache = (*this_prologue_cache);
+  struct dummy_frame_cache *cache
+    = (struct dummy_frame_cache *) *this_prologue_cache;
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct value *reg_val;
 
@@ -252,15 +354,15 @@ dummy_frame_prev_register (struct frame_info *this_frame,
   /* Use the regcache_cooked_read() method so that it, on the fly,
      constructs either a raw or pseudo register from the raw
      register cache.  */
-  regcache_cooked_read (cache->prev_regcache, regnum,
-			value_contents_writeable (reg_val));
+  cache->prev_regcache->cooked_read (regnum,
+				     value_contents_writeable (reg_val));
   return reg_val;
 }
 
 /* Assuming that THIS_FRAME is a dummy, return its ID.  That ID is
    determined by examining the NEXT frame's unwound registers using
    the method dummy_id().  As a side effect, THIS dummy frame's
-   dummy cache is located and and saved in THIS_PROLOGUE_CACHE.  */
+   dummy cache is located and saved in THIS_PROLOGUE_CACHE.  */
 
 static void
 dummy_frame_this_id (struct frame_info *this_frame,
@@ -268,24 +370,34 @@ dummy_frame_this_id (struct frame_info *this_frame,
 		     struct frame_id *this_id)
 {
   /* The dummy-frame sniffer always fills in the cache.  */
-  struct dummy_frame_cache *cache = (*this_prologue_cache);
+  struct dummy_frame_cache *cache
+    = (struct dummy_frame_cache *) *this_prologue_cache;
 
   gdb_assert (cache != NULL);
   (*this_id) = cache->this_id;
 }
 
-static const struct frame_unwind dummy_frame_unwinder =
+const struct frame_unwind dummy_frame_unwind =
 {
   DUMMY_FRAME,
+  default_frame_unwind_stop_reason,
   dummy_frame_this_id,
   dummy_frame_prev_register,
   NULL,
   dummy_frame_sniffer,
 };
 
-const struct frame_unwind *const dummy_frame_unwind = {
-  &dummy_frame_unwinder
-};
+/* See dummy-frame.h.  */
+
+struct frame_id
+default_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+  CORE_ADDR sp, pc;
+
+  sp = get_frame_sp (this_frame);
+  pc = get_frame_pc (this_frame);
+  return frame_id_build (sp, pc);
+}
 
 static void
 fprint_dummy_frames (struct ui_file *file)
@@ -297,31 +409,28 @@ fprint_dummy_frames (struct ui_file *file)
       gdb_print_host_address (s, file);
       fprintf_unfiltered (file, ":");
       fprintf_unfiltered (file, " id=");
-      fprint_frame_id (file, s->id);
+      fprint_frame_id (file, s->id.id);
+      fprintf_unfiltered (file, ", ptid=%s",
+			  target_pid_to_str (s->id.thread->ptid).c_str ());
       fprintf_unfiltered (file, "\n");
     }
 }
 
 static void
-maintenance_print_dummy_frames (char *args, int from_tty)
+maintenance_print_dummy_frames (const char *args, int from_tty)
 {
   if (args == NULL)
     fprint_dummy_frames (gdb_stdout);
   else
     {
-      struct cleanup *cleanups;
-      struct ui_file *file = gdb_fopen (args, "w");
+      stdio_file file;
 
-      if (file == NULL)
+      if (!file.open (args, "w"))
 	perror_with_name (_("maintenance print dummy-frames"));
-      cleanups = make_cleanup_ui_file_delete (file);
-      fprint_dummy_frames (file);    
-      do_cleanups (cleanups);
+      fprint_dummy_frames (&file);
     }
 }
 
-extern void _initialize_dummy_frame (void);
-
 void
 _initialize_dummy_frame (void)
 {
@@ -329,5 +438,5 @@ _initialize_dummy_frame (void)
 	   _("Print the contents of the internal dummy-frame stack."),
 	   &maintenanceprintlist);
 
-  observer_attach_inferior_created (cleanup_dummy_frames);
+  gdb::observers::inferior_created.attach (cleanup_dummy_frames);
 }