gdb/gdb-6.3-ia64-sigaltstack-20050711.patch

2005-07-11  Jeff Johnston  <jjohnstn@redhat.com>

	* ia64-tdep.c (pseudo_regs): Add CURSOR_ADDR_REGNUM.
	(ia64_register_names): Add empty string for CURSOR_ADDR_REGNUM.
	(ia64_frame_prev_register): Default a request for CURSOR_ADDR_REGNUM
	to return 0.
	(ia64_sigtramp_frame_prev_register): Ditto.
	(ia64_gdb2uw_regnum): Map CURSOR_ADDR_REGNUM to INT_MAX so
	it won't clash with any legitimate UNW register number.
	(ia64_unwind_cursor): New callback.
	(ia64_libunwind_descr): Add new ia64_unwind_cursor callback.
	* libunwind-frame.h (struct libunwind_descr): Add new slot
	for unwind cursor callback.
	* libunwind-frame.c (libunwind_frame_cache): Attempt to copy
	and step previous cursor if possible, otherwise, create new
	cursor.
	(libunwind_frame_prev_register): Support request for
	getting the cursor address.

--- gdb-6.3/gdb/ia64-tdep.c.fix	2005-07-11 18:13:42.000000000 -0400
+++ gdb-6.3/gdb/ia64-tdep.c	2005-07-11 18:15:52.000000000 -0400
@@ -141,7 +141,7 @@ static int lr_regnum = IA64_VRAP_REGNUM;
    they may not be accessible via the ptrace register get/set interfaces.  */
 enum pseudo_regs { FIRST_PSEUDO_REGNUM = NUM_IA64_RAW_REGS, VBOF_REGNUM = IA64_NAT127_REGNUM + 1, V32_REGNUM, 
 		   V127_REGNUM = V32_REGNUM + 95, 
-		   VP0_REGNUM, VP16_REGNUM = VP0_REGNUM + 16, VP63_REGNUM = VP0_REGNUM + 63, LAST_PSEUDO_REGNUM };
+		   VP0_REGNUM, VP16_REGNUM = VP0_REGNUM + 16, VP63_REGNUM = VP0_REGNUM + 63, CURSOR_ADDR_REGNUM, LAST_PSEUDO_REGNUM };
 
 /* Array of register names; There should be ia64_num_regs strings in
    the initializer.  */
@@ -253,6 +253,7 @@ static char *ia64_register_names[] = 
   "p40",  "p41",  "p42",  "p43",  "p44",  "p45",  "p46",  "p47",
   "p48",  "p49",  "p50",  "p51",  "p52",  "p53",  "p54",  "p55",
   "p56",  "p57",  "p58",  "p59",  "p60",  "p61",  "p62",  "p63",
+  ""
 };
 
 struct ia64_frame_cache
@@ -1855,6 +1856,12 @@ ia64_frame_prev_register (struct frame_i
 	  read_memory (addr, valuep, register_size (current_gdbarch, regnum));
         }
     }
+  else if (regnum == CURSOR_ADDR_REGNUM)
+    {
+      /* The cursor is the address of the ia64 libunwind cursor.  
+         Default to 0.  */
+      *lvalp = lval_memory;
+    }
   else
     {
       CORE_ADDR addr = 0;
@@ -2177,6 +2184,12 @@ ia64_sigtramp_frame_prev_register (struc
 	  *addrp = pr_addr;
 	}
     }
+  else if (regnum == CURSOR_ADDR_REGNUM)
+    {
+      /* The cursor is the address of the ia64 libunwind cursor.  
+         Default to 0.  */
+      *lvalp = lval_memory;
+    }
   else
     {
       /* All other registers not listed above.  */
@@ -2296,6 +2309,8 @@ ia64_gdb2uw_regnum (int regnum)
     return UNW_IA64_AR + (regnum - IA64_AR0_REGNUM);
   else if ((unsigned) (regnum - IA64_NAT0_REGNUM) < 128)
     return UNW_IA64_NAT + (regnum - IA64_NAT0_REGNUM);
+  else if (regnum == CURSOR_ADDR_REGNUM)
+    return INT_MAX;
   else
     return -1;
 }
@@ -2331,6 +2346,21 @@ ia64_uw2gdb_regnum (int uw_regnum)
     return -1;
 }
 
+/* Special callback function to allow libunwind-frame to get
+   the address of the next frame's cursor so it may be copied and
+   stepped.  */
+static unw_cursor_t *
+ia64_unwind_cursor (struct frame_info *next_frame)
+{
+  unw_cursor_t *cursor_addr;
+  char buf[8];
+
+  frame_unwind_register (next_frame, CURSOR_ADDR_REGNUM, buf);
+  cursor_addr = (unw_cursor_t *)extract_unsigned_integer (buf, 8);
+
+  return cursor_addr;
+}
+
 /* Gdb libunwind-frame callback function to reveal if register is a float 
    register or not.  */
 static int
@@ -3111,6 +3141,7 @@ static struct libunwind_descr ia64_libun
   ia64_gdb2uw_regnum, 
   ia64_uw2gdb_regnum, 
   ia64_is_fpreg, 
+  ia64_unwind_cursor, 
   &ia64_unw_accessors,
   &ia64_unw_rse_accessors,
 };
--- gdb-6.3/gdb/libunwind-frame.c.fix	2005-07-11 18:17:05.000000000 -0400
+++ gdb-6.3/gdb/libunwind-frame.c	2005-07-11 18:20:31.000000000 -0400
@@ -122,6 +122,7 @@ libunwind_frame_set_descr (struct gdbarc
   arch_descr->is_fpreg = descr->is_fpreg;
   arch_descr->accessors = descr->accessors;
   arch_descr->special_accessors = descr->special_accessors;
+  arch_descr->unwind_cursor = descr->unwind_cursor;
 }
 
 static struct libunwind_frame_cache *
@@ -129,6 +130,7 @@ libunwind_frame_cache (struct frame_info
 {
   unw_accessors_t *acc;
   unw_addr_space_t as;
+  unw_cursor_t *cursor_addr;
   unw_word_t fp;
   unw_regnum_t uw_sp_regnum;
   struct libunwind_frame_cache *cache;
@@ -147,22 +149,33 @@ libunwind_frame_cache (struct frame_info
       && get_frame_type (next_frame) != SIGTRAMP_FRAME)
     return NULL;
 
-  /* Get a libunwind cursor to the previous frame.  We do this by initializing
-     a cursor.  Libunwind treats a new cursor as the top of stack and will get
-     the current register set via the libunwind register accessor.  Now, we
-     provide the platform-specific accessors and we set up the register accessor to use
-     the frame register unwinding interfaces so that we properly get the registers for
-     the current frame rather than the top.  We then use the  unw_step function to 
-     move the libunwind cursor back one frame.  We can later use this cursor to find previous 
-     registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
+  /* Get a libunwind cursor to the previous frame.  We do this by getting
+     the address of the next frame's cursor (if one exists).  If we are at 
+     the top of stack, then we will get back a zero cursor address and we 
+     should initialize a new cursor.
+
+     Otherwise, we copy the cursor address contents and step back by one.
+     Libunwind will use our register accessors which are set up to
+     unwind registers from the previous frame.  We will later use this cursor
+     to find previous registers via the unw_get_reg interface.  By passing
+     back a cursor, we allow libunwind to handle sigaltstack which requires
+     one cursor stepped back for all frames.  */
   descr = libunwind_descr (get_frame_arch (next_frame));
-  acc = descr->accessors;
-  as =  unw_create_addr_space_p (acc,
+  cursor_addr = descr->unwind_cursor (next_frame);
+
+  if (cursor_addr == 0)
+    {
+      acc = descr->accessors;
+      as =  unw_create_addr_space_p (acc,
 				 TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 				 ? __BIG_ENDIAN
 				 : __LITTLE_ENDIAN);
 
-  unw_init_remote_p (&cache->cursor, as, next_frame);
+      unw_init_remote_p (&cache->cursor, as, next_frame);
+    }
+  else /* make copy */
+    cache->cursor = *cursor_addr;
+
   if (unw_step_p (&cache->cursor) < 0)
     return NULL;
 
@@ -285,6 +298,16 @@ libunwind_frame_prev_register (struct fr
   if (uw_regnum < 0)
     return;
 
+  /* Check if we are unwinding the cursor address which just gives
+     back the address of the next frame's cursor.  This is a special
+     modification to support unwinding through a sigaltstack.  */
+  if (uw_regnum == INT_MAX)
+    {
+      store_unsigned_integer (valuep, sizeof (CORE_ADDR), 
+			      (CORE_ADDR)&cache->cursor);
+      return;
+    }
+
   /* To get the previous register, we use the libunwind register APIs with
      the cursor we have already pushed back to the previous frame.  */
 
--- gdb-6.3/gdb/libunwind-frame.h.fix	2005-07-11 18:17:24.000000000 -0400
+++ gdb-6.3/gdb/libunwind-frame.h	2005-07-11 18:18:46.000000000 -0400
@@ -37,6 +37,7 @@ struct libunwind_descr
   int (*gdb2uw) (int);
   int (*uw2gdb) (int);
   int (*is_fpreg) (int);
+  unw_cursor_t *(*unwind_cursor) (struct frame_info *next_frame);
   void *accessors;
   void *special_accessors;
 };