X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftramp-frame.c;h=f6a9763565131d31df0ff52bf4a45c9513266842;hb=e671856cb804c977650aaeb4107948a7b963e9e9;hp=ee3635f743b81ac9e80caecabcdfb49f89537e49;hpb=1196bfdaf9becb2a90e01bec41fc18b24affad38;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/tramp-frame.c b/gdb/tramp-frame.c
index ee3635f743..f6a9763565 100644
--- a/gdb/tramp-frame.c
+++ b/gdb/tramp-frame.c
@@ -1,12 +1,12 @@
 /* Signal trampoline unwinder, for GDB the GNU Debugger.
 
-   Copyright 2004 Free Software Foundation, Inc.
+   Copyright (C) 2004-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "tramp-frame.h"
@@ -28,7 +26,6 @@
 #include "target.h"
 #include "trad-frame.h"
 #include "frame-base.h"
-#include "gdb_assert.h"
 
 struct frame_data
 {
@@ -43,16 +40,17 @@ struct tramp_frame_cache
 };
 
 static struct trad_frame_cache *
-tramp_frame_cache (struct frame_info *next_frame,
+tramp_frame_cache (struct frame_info *this_frame,
 		   void **this_cache)
 {
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
-  struct tramp_frame_cache *tramp_cache = (*this_cache);
+  struct tramp_frame_cache *tramp_cache
+    = (struct tramp_frame_cache *) *this_cache;
+
   if (tramp_cache->trad_cache == NULL)
     {
-      tramp_cache->trad_cache = trad_frame_cache_zalloc (next_frame);
+      tramp_cache->trad_cache = trad_frame_cache_zalloc (this_frame);
       tramp_cache->tramp_frame->init (tramp_cache->tramp_frame,
-				      next_frame,
+				      this_frame,
 				      tramp_cache->trad_cache,
 				      tramp_cache->func);
     }
@@ -60,51 +58,59 @@ tramp_frame_cache (struct frame_info *next_frame,
 }
 
 static void
-tramp_frame_this_id (struct frame_info *next_frame,
+tramp_frame_this_id (struct frame_info *this_frame,
 		     void **this_cache,
 		     struct frame_id *this_id)
 {
   struct trad_frame_cache *trad_cache
-    = tramp_frame_cache (next_frame, this_cache);
+    = tramp_frame_cache (this_frame, this_cache);
+
   trad_frame_get_id (trad_cache, this_id);
 }
 
-static void
-tramp_frame_prev_register (struct frame_info *next_frame,
+static struct value *
+tramp_frame_prev_register (struct frame_info *this_frame,
 			   void **this_cache,
-			   int prev_regnum,
-			   int *optimizedp,
-			   enum lval_type * lvalp,
-			   CORE_ADDR *addrp,
-			   int *realnump, void *valuep)
+			   int prev_regnum)
 {
   struct trad_frame_cache *trad_cache
-    = tramp_frame_cache (next_frame, this_cache);
-  trad_frame_get_register (trad_cache, next_frame, prev_regnum, optimizedp,
-			   lvalp, addrp, realnump, valuep);
+    = tramp_frame_cache (this_frame, this_cache);
+
+  return trad_frame_get_register (trad_cache, this_frame, prev_regnum);
 }
 
 static CORE_ADDR
-tramp_frame_start (CORE_ADDR pc, const struct tramp_frame *tramp)
+tramp_frame_start (const struct tramp_frame *tramp,
+		   struct frame_info *this_frame, CORE_ADDR pc)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int ti;
+
+  /* Check if we can use this trampoline.  */
+  if (tramp->validate && !tramp->validate (tramp, this_frame, &pc))
+    return 0;
+
   /* Search through the trampoline for one that matches the
      instruction sequence around PC.  */
-  for (ti = 0; tramp->insn[ti] != TRAMP_SENTINEL_INSN; ti++)
+  for (ti = 0; tramp->insn[ti].bytes != TRAMP_SENTINEL_INSN; ti++)
     {
       CORE_ADDR func = pc - tramp->insn_size * ti;
       int i;
+
       for (i = 0; 1; i++)
 	{
-	  bfd_byte buf[sizeof (tramp->insn[0])];
+	  gdb_byte buf[sizeof (tramp->insn[0])];
 	  ULONGEST insn;
-	  if (tramp->insn[i] == TRAMP_SENTINEL_INSN)
+
+	  if (tramp->insn[i].bytes == TRAMP_SENTINEL_INSN)
 	    return func;
-	  if (target_read_memory (func + i * tramp->insn_size, buf,
-				  tramp->insn_size) != 0)
+	  if (!safe_frame_unwind_memory (this_frame,
+					 func + i * tramp->insn_size,
+					 buf, tramp->insn_size))
 	    break;
-	  insn = extract_unsigned_integer (buf, tramp->insn_size);
-	  if (tramp->insn[i] != insn)
+	  insn = extract_unsigned_integer (buf, tramp->insn_size, byte_order);
+	  if (tramp->insn[i].bytes != (insn & tramp->insn[i].mask))
 	    break;
 	}
     }
@@ -114,26 +120,19 @@ tramp_frame_start (CORE_ADDR pc, const struct tramp_frame *tramp)
 
 static int
 tramp_frame_sniffer (const struct frame_unwind *self,
-		     struct frame_info *next_frame,
+		     struct frame_info *this_frame,
 		     void **this_cache)
 {
   const struct tramp_frame *tramp = self->unwind_data->tramp_frame;
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  CORE_ADDR pc = get_frame_pc (this_frame);
   CORE_ADDR func;
-  char *name;
   struct tramp_frame_cache *tramp_cache;
 
-  /* If the function has a valid symbol name, it isn't a
-     trampoline.  */
-  find_pc_partial_function (pc, &name, NULL, NULL);
-  if (name != NULL)
-    return 0;
-  /* If the function lives in a valid section (even without a starting
-     point) it isn't a trampoline.  */
-  if (find_pc_section (pc) != NULL)
-    return 0;
-  /* Finally, check that the trampoline matches at PC.  */
-  func = tramp_frame_start (pc, tramp);
+  /* tausq/2004-12-12: We used to assume if pc has a name or is in a valid 
+     section, then this is not a trampoline.  However, this assumption is
+     false on HPUX which has a signal trampoline that has a name; it can
+     also be false when using an alternative signal stack.  */
+  func = tramp_frame_start (tramp, this_frame, pc);
   if (func == 0)
     return 0;
   tramp_cache = FRAME_OBSTACK_ZALLOC (struct tramp_frame_cache);
@@ -144,8 +143,8 @@ tramp_frame_sniffer (const struct frame_unwind *self,
 }
 
 void
-tramp_frame_append (struct gdbarch *gdbarch,
-		    const struct tramp_frame *tramp_frame)
+tramp_frame_prepend_unwinder (struct gdbarch *gdbarch,
+			      const struct tramp_frame *tramp_frame)
 {
   struct frame_data *data;
   struct frame_unwind *unwinder;
@@ -154,20 +153,21 @@ tramp_frame_append (struct gdbarch *gdbarch,
   /* Check that the instruction sequence contains a sentinel.  */
   for (i = 0; i < ARRAY_SIZE (tramp_frame->insn); i++)
     {
-      if (tramp_frame->insn[i] == TRAMP_SENTINEL_INSN)
+      if (tramp_frame->insn[i].bytes == TRAMP_SENTINEL_INSN)
 	break;
     }
   gdb_assert (i < ARRAY_SIZE (tramp_frame->insn));
-  gdb_assert (tramp_frame->insn_size <= sizeof (tramp_frame->insn[0]));
+  gdb_assert (tramp_frame->insn_size <= sizeof (tramp_frame->insn[0].bytes));
 
   data = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_data);
   unwinder = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind);
 
   data->tramp_frame = tramp_frame;
-  unwinder->type = SIGTRAMP_FRAME;
+  unwinder->type = tramp_frame->frame_type;
   unwinder->unwind_data = data;
   unwinder->sniffer = tramp_frame_sniffer;
+  unwinder->stop_reason = default_frame_unwind_stop_reason;
   unwinder->this_id = tramp_frame_this_id;
   unwinder->prev_register = tramp_frame_prev_register;
-  frame_unwind_register_unwinder (gdbarch, unwinder);
+  frame_unwind_prepend_unwinder (gdbarch, unwinder);
 }