[commit] update alpha-osf to new value-based unwinding

[commit] update alpha-osf to new value-based unwinding

[Joel Brobecker]

Hello,

I just committed the following patch to update the alpha-osf port
to the new value-based unwinding approach. I couldn't test it with
the testsuite because, for some reason,  I can't make dejagnu/expect
/tcl work anymore. So I used AdaCore's GDB testsuite instead.

2008-05-08  Joel Brobecker  <brobecker@adacore.com>

        * alpha-mdebug-tdep.c, alpha-osf1-tdep.c, alpha-tdep.c:
        Update for unwinder changes.

Checked in.

This is the last platform that I have access to which wasn't converted
before. I don't mind helping with others but, like Daniel, it will
be without the benefit of testing.

-- 
Joel

Re: [commit] update alpha-osf to new value-based unwinding

[Joel Brobecker]

[-- Attachment #1: Type: text/plain, Size: 258 bytes --]

> 2008-05-08  Joel Brobecker  <brobecker@adacore.com>
> 
>         * alpha-mdebug-tdep.c, alpha-osf1-tdep.c, alpha-tdep.c:
>         Update for unwinder changes.
> 
> Checked in.

ENOPATCH (I'm surprised it's been that long since the last time...)

-- 
Joel

[-- Attachment #2: alpha-value-unwind.diff --]
[-- Type: text/plain, Size: 20157 bytes --]

Index: alpha-mdebug-tdep.c
===================================================================
--- alpha-mdebug-tdep.c	(revision 130742)
+++ alpha-mdebug-tdep.c	(working copy)
@@ -177,7 +177,7 @@ struct alpha_mdebug_unwind_cache
    and store the resulting register save locations in the structure.  */
 
 static struct alpha_mdebug_unwind_cache *
-alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, 
+alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame, 
 				 void **this_prologue_cache)
 {
   struct alpha_mdebug_unwind_cache *info;
@@ -192,7 +192,7 @@ alpha_mdebug_frame_unwind_cache (struct 
 
   info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
   *this_prologue_cache = info;
-  pc = frame_pc_unwind (next_frame);
+  pc = get_frame_pc (this_frame);
 
   /* ??? We don't seem to be able to cache the lookup of the PDR
      from alpha_mdebug_frame_p.  It'd be nice if we could change
@@ -204,7 +204,7 @@ alpha_mdebug_frame_unwind_cache (struct 
   info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
 
   /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET.  */
-  vfp = frame_unwind_register_unsigned (next_frame, PROC_FRAME_REG (proc_desc));
+  vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
   vfp += PROC_FRAME_OFFSET (info->proc_desc);
   info->vfp = vfp;
 
@@ -249,28 +249,24 @@ alpha_mdebug_frame_unwind_cache (struct 
    frame.  This will be used to create a new GDB frame struct.  */
 
 static void
-alpha_mdebug_frame_this_id (struct frame_info *next_frame,
+alpha_mdebug_frame_this_id (struct frame_info *this_frame,
 			    void **this_prologue_cache,
 			    struct frame_id *this_id)
 {
   struct alpha_mdebug_unwind_cache *info
-    = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
 
-  *this_id = frame_id_build (info->vfp,
-			     frame_func_unwind (next_frame, NORMAL_FRAME));
+  *this_id = frame_id_build (info->vfp, get_frame_func (this_frame));
 }
 
 /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
 
-static void
-alpha_mdebug_frame_prev_register (struct frame_info *next_frame,
-				  void **this_prologue_cache,
-				  int regnum, int *optimizedp,
-				  enum lval_type *lvalp, CORE_ADDR *addrp,
-				  int *realnump, gdb_byte *bufferp)
+static struct value *
+alpha_mdebug_frame_prev_register (struct frame_info *this_frame,
+				  void **this_prologue_cache, int regnum)
 {
   struct alpha_mdebug_unwind_cache *info
-    = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
 
   /* The PC of the previous frame is stored in the link register of
      the current frame.  Frob regnum so that we pull the value from
@@ -281,90 +277,74 @@ alpha_mdebug_frame_prev_register (struct
   /* For all registers known to be saved in the current frame, 
      do the obvious and pull the value out.  */
   if (info->saved_regs[regnum])
-    {
-      *optimizedp = 0;
-      *lvalp = lval_memory;
-      *addrp = info->saved_regs[regnum];
-      *realnump = -1;
-      if (bufferp != NULL)
-	get_frame_memory (next_frame, *addrp, bufferp, ALPHA_REGISTER_SIZE);
-      return;
-    }
+    return frame_unwind_got_memory (this_frame, regnum,
+                                    info->saved_regs[regnum]);
 
   /* The stack pointer of the previous frame is computed by popping
      the current stack frame.  */
   if (regnum == ALPHA_SP_REGNUM)
-    {
-      *optimizedp = 0;
-      *lvalp = not_lval;
-      *addrp = 0;
-      *realnump = -1;
-      if (bufferp != NULL)
-	store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp);
-      return;
-    }
+    return frame_unwind_got_constant (this_frame, regnum, info->vfp);
 
   /* Otherwise assume the next frame has the same register value.  */
-  *optimizedp = 0;
-  *lvalp = lval_register;
-  *addrp = 0;
-  *realnump = regnum;
-  if (bufferp)
-    frame_unwind_register (next_frame, *realnump, bufferp);
+    return frame_unwind_got_register (this_frame, regnum, regnum);
 }
 
-static const struct frame_unwind alpha_mdebug_frame_unwind = {
-  NORMAL_FRAME,
-  alpha_mdebug_frame_this_id,
-  alpha_mdebug_frame_prev_register
-};
-
-const struct frame_unwind *
-alpha_mdebug_frame_sniffer (struct frame_info *next_frame)
+static int
+alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
+                            struct frame_info *this_frame,
+                            void **this_cache)
 {
-  CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+  CORE_ADDR pc = get_frame_address_in_block (this_frame);
   struct mdebug_extra_func_info *proc_desc;
 
   /* If this PC does not map to a PDR, then clearly this isn't an
      mdebug frame.  */
   proc_desc = find_proc_desc (pc);
   if (proc_desc == NULL)
-    return NULL;
+    return 0;
 
   /* If we're in the prologue, the PDR for this frame is not yet valid.
      Say no here and we'll fall back on the heuristic unwinder.  */
   if (alpha_mdebug_in_prologue (pc, proc_desc))
-    return NULL;
+    return 0;
 
-  return &alpha_mdebug_frame_unwind;
+  return 1;
 }
 
+static const struct frame_unwind alpha_mdebug_frame_unwind = {
+  NORMAL_FRAME,
+  alpha_mdebug_frame_this_id,
+  alpha_mdebug_frame_prev_register,
+  NULL,
+  alpha_mdebug_frame_sniffer
+};
+
 static CORE_ADDR
-alpha_mdebug_frame_base_address (struct frame_info *next_frame,
+alpha_mdebug_frame_base_address (struct frame_info *this_frame,
 				 void **this_prologue_cache)
 {
   struct alpha_mdebug_unwind_cache *info
-    = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
 
   return info->vfp;
 }
 
 static CORE_ADDR
-alpha_mdebug_frame_locals_address (struct frame_info *next_frame,
+alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
 				   void **this_prologue_cache)
 {
   struct alpha_mdebug_unwind_cache *info
-    = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
 
   return info->vfp - PROC_LOCALOFF (info->proc_desc);
 }
 
 static CORE_ADDR
-alpha_mdebug_frame_args_address (struct frame_info *next_frame,
+alpha_mdebug_frame_args_address (struct frame_info *this_frame,
 				 void **this_prologue_cache)
 {
   struct alpha_mdebug_unwind_cache *info
-    = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
 
   return info->vfp - ALPHA_NUM_ARG_REGS * 8;
 }
@@ -377,9 +357,9 @@ static const struct frame_base alpha_mde
 };
 
 static const struct frame_base *
-alpha_mdebug_frame_base_sniffer (struct frame_info *next_frame)
+alpha_mdebug_frame_base_sniffer (struct frame_info *this_frame)
 {
-  CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+  CORE_ADDR pc = get_frame_address_in_block (this_frame);
   struct mdebug_extra_func_info *proc_desc;
 
   /* If this PC does not map to a PDR, then clearly this isn't an
@@ -397,6 +377,6 @@ alpha_mdebug_init_abi (struct gdbarch_in
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-  frame_unwind_append_sniffer (gdbarch, alpha_mdebug_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
   frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
 }
Index: alpha-osf1-tdep.c
===================================================================
--- alpha-osf1-tdep.c	(revision 130742)
+++ alpha-osf1-tdep.c	(working copy)
@@ -33,9 +33,13 @@ alpha_osf1_pc_in_sigtramp (CORE_ADDR pc,
 }
 
 static CORE_ADDR
-alpha_osf1_sigcontext_addr (struct frame_info *next_frame)
+alpha_osf1_sigcontext_addr (struct frame_info *this_frame)
 {
-  const struct frame_id next_id = get_frame_id (next_frame);
+  struct frame_info *next_frame = get_next_frame (this_frame);
+  struct frame_id next_id = null_frame_id;
+  
+  if (next_frame != NULL)
+    next_id = get_frame_id (next_frame);
 
   return (read_memory_integer (next_id.stack_addr, 8));
 }
Index: alpha-tdep.c
===================================================================
--- alpha-tdep.c	(revision 130742)
+++ alpha-tdep.c	(working copy)
@@ -747,7 +747,7 @@ struct alpha_sigtramp_unwind_cache
 };
 
 static struct alpha_sigtramp_unwind_cache *
-alpha_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
+alpha_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 				   void **this_prologue_cache)
 {
   struct alpha_sigtramp_unwind_cache *info;
@@ -759,8 +759,8 @@ alpha_sigtramp_frame_unwind_cache (struc
   info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
   *this_prologue_cache = info;
 
-  tdep = gdbarch_tdep (get_frame_arch (next_frame));
-  info->sigcontext_addr = tdep->sigcontext_addr (next_frame);
+  tdep = gdbarch_tdep (get_frame_arch (this_frame));
+  info->sigcontext_addr = tdep->sigcontext_addr (this_frame);
 
   return info;
 }
@@ -788,14 +788,14 @@ alpha_sigtramp_register_address (struct 
    frame.  This will be used to create a new GDB frame struct.  */
 
 static void
-alpha_sigtramp_frame_this_id (struct frame_info *next_frame,
+alpha_sigtramp_frame_this_id (struct frame_info *this_frame,
 			      void **this_prologue_cache,
 			      struct frame_id *this_id)
 {
-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   struct alpha_sigtramp_unwind_cache *info
-    = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
   CORE_ADDR stack_addr, code_addr;
 
   /* If the OSABI couldn't locate the sigcontext, give up.  */
@@ -808,7 +808,7 @@ alpha_sigtramp_frame_this_id (struct fra
   if (tdep->dynamic_sigtramp_offset)
     {
       int offset;
-      code_addr = frame_pc_unwind (next_frame);
+      code_addr = get_frame_pc (this_frame);
       offset = tdep->dynamic_sigtramp_offset (code_addr);
       if (offset >= 0)
 	code_addr -= offset;
@@ -816,12 +816,12 @@ alpha_sigtramp_frame_this_id (struct fra
 	code_addr = 0;
     }
   else
-    code_addr = frame_func_unwind (next_frame, SIGTRAMP_FRAME);
+    code_addr = get_frame_func (this_frame);
 
   /* The stack address is trivially read from the sigcontext.  */
   stack_addr = alpha_sigtramp_register_address (gdbarch, info->sigcontext_addr,
 						ALPHA_SP_REGNUM);
-  stack_addr = get_frame_memory_unsigned (next_frame, stack_addr,
+  stack_addr = get_frame_memory_unsigned (this_frame, stack_addr,
 					  ALPHA_REGISTER_SIZE);
 
   *this_id = frame_id_build (stack_addr, code_addr);
@@ -829,57 +829,37 @@ alpha_sigtramp_frame_this_id (struct fra
 
 /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
 
-static void
-alpha_sigtramp_frame_prev_register (struct frame_info *next_frame,
-				    void **this_prologue_cache,
-				    int regnum, int *optimizedp,
-				    enum lval_type *lvalp, CORE_ADDR *addrp,
-				    int *realnump, gdb_byte *bufferp)
+static struct value *
+alpha_sigtramp_frame_prev_register (struct frame_info *this_frame,
+				    void **this_prologue_cache, int regnum)
 {
   struct alpha_sigtramp_unwind_cache *info
-    = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+    = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
   CORE_ADDR addr;
 
   if (info->sigcontext_addr != 0)
     {
       /* All integer and fp registers are stored in memory.  */
-      addr = alpha_sigtramp_register_address (get_frame_arch (next_frame),
+      addr = alpha_sigtramp_register_address (get_frame_arch (this_frame),
 					      info->sigcontext_addr, regnum);
       if (addr != 0)
-	{
-	  *optimizedp = 0;
-	  *lvalp = lval_memory;
-	  *addrp = addr;
-	  *realnump = -1;
-	  if (bufferp != NULL)
-	    get_frame_memory (next_frame, addr, bufferp, ALPHA_REGISTER_SIZE);
-	  return;
-	}
+        return frame_unwind_got_memory (this_frame, regnum, addr);
     }
 
   /* This extra register may actually be in the sigcontext, but our
      current description of it in alpha_sigtramp_frame_unwind_cache
      doesn't include it.  Too bad.  Fall back on whatever's in the
      outer frame.  */
-  *optimizedp = 0;
-  *lvalp = lval_register;
-  *addrp = 0;
-  *realnump = regnum;
-  if (bufferp)
-    frame_unwind_register (next_frame, *realnump, bufferp);
+  return frame_unwind_got_register (this_frame, regnum, regnum);
 }
 
-static const struct frame_unwind alpha_sigtramp_frame_unwind = {
-  SIGTRAMP_FRAME,
-  alpha_sigtramp_frame_this_id,
-  alpha_sigtramp_frame_prev_register
-};
-
-static const struct frame_unwind *
-alpha_sigtramp_frame_sniffer (struct frame_info *next_frame)
+static int
+alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
+                              struct frame_info *this_frame,
+                              void **this_prologue_cache)
 {
-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  CORE_ADDR pc = get_frame_pc (this_frame);
   char *name;
 
   /* NOTE: cagney/2004-04-30: Do not copy/clone this code.  Instead
@@ -889,17 +869,26 @@ alpha_sigtramp_frame_sniffer (struct fra
   /* We shouldn't even bother to try if the OSABI didn't register a
      sigcontext_addr handler or pc_in_sigtramp hander.  */
   if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
-    return NULL;
+    return 0;
   if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
-    return NULL;
+    return 0;
 
   /* Otherwise we should be in a signal frame.  */
   find_pc_partial_function (pc, &name, NULL, NULL);
   if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (pc, name))
-    return &alpha_sigtramp_frame_unwind;
+    return 1;
 
-  return NULL;
+  return 0;
 }
+
+static const struct frame_unwind alpha_sigtramp_frame_unwind = {
+  SIGTRAMP_FRAME,
+  alpha_sigtramp_frame_this_id,
+  alpha_sigtramp_frame_prev_register,
+  NULL,
+  alpha_sigtramp_frame_sniffer
+};
+
 \f
 
 /* Heuristic_proc_start may hunt through the text section for a long
@@ -999,11 +988,11 @@ struct alpha_heuristic_unwind_cache
 };
 
 static struct alpha_heuristic_unwind_cache *
-alpha_heuristic_frame_unwind_cache (struct frame_info *next_frame,
+alpha_heuristic_frame_unwind_cache (struct frame_info *this_frame,
 				    void **this_prologue_cache,
 				    CORE_ADDR start_pc)
 {
-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct alpha_heuristic_unwind_cache *info;
   ULONGEST val;
   CORE_ADDR limit_pc, cur_pc;
@@ -1014,9 +1003,9 @@ alpha_heuristic_frame_unwind_cache (stru
 
   info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
   *this_prologue_cache = info;
-  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
-  limit_pc = frame_pc_unwind (next_frame);
+  limit_pc = get_frame_pc (this_frame);
   if (start_pc == 0)
     start_pc = alpha_heuristic_proc_start (gdbarch, limit_pc);
   info->start_pc = start_pc;
@@ -1151,7 +1140,7 @@ alpha_heuristic_frame_unwind_cache (stru
     return_reg = ALPHA_RA_REGNUM;
   info->return_reg = return_reg;
 
-  val = frame_unwind_register_unsigned (next_frame, frame_reg);
+  val = get_frame_register_unsigned (this_frame, frame_reg);
   info->vfp = val + frame_size;
 
   /* Convert offsets to absolute addresses.  See above about adding
@@ -1167,27 +1156,24 @@ alpha_heuristic_frame_unwind_cache (stru
    frame.  This will be used to create a new GDB frame struct.  */
 
 static void
-alpha_heuristic_frame_this_id (struct frame_info *next_frame,
-				 void **this_prologue_cache,
-				 struct frame_id *this_id)
+alpha_heuristic_frame_this_id (struct frame_info *this_frame,
+			       void **this_prologue_cache,
+			       struct frame_id *this_id)
 {
   struct alpha_heuristic_unwind_cache *info
-    = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
+    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
 
   *this_id = frame_id_build (info->vfp, info->start_pc);
 }
 
 /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
 
-static void
-alpha_heuristic_frame_prev_register (struct frame_info *next_frame,
-				     void **this_prologue_cache,
-				     int regnum, int *optimizedp,
-				     enum lval_type *lvalp, CORE_ADDR *addrp,
-				     int *realnump, gdb_byte *bufferp)
+static struct value *
+alpha_heuristic_frame_prev_register (struct frame_info *this_frame,
+				     void **this_prologue_cache, int regnum)
 {
   struct alpha_heuristic_unwind_cache *info
-    = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
+    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
 
   /* The PC of the previous frame is stored in the link register of
      the current frame.  Frob regnum so that we pull the value from
@@ -1195,28 +1181,23 @@ alpha_heuristic_frame_prev_register (str
   if (regnum == ALPHA_PC_REGNUM)
     regnum = info->return_reg;
   
-  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
-				optimizedp, lvalp, addrp, realnump, bufferp);
+  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 }
 
 static const struct frame_unwind alpha_heuristic_frame_unwind = {
   NORMAL_FRAME,
   alpha_heuristic_frame_this_id,
-  alpha_heuristic_frame_prev_register
+  alpha_heuristic_frame_prev_register,
+  NULL,
+  default_frame_sniffer
 };
 
-static const struct frame_unwind *
-alpha_heuristic_frame_sniffer (struct frame_info *next_frame)
-{
-  return &alpha_heuristic_frame_unwind;
-}
-
 static CORE_ADDR
-alpha_heuristic_frame_base_address (struct frame_info *next_frame,
+alpha_heuristic_frame_base_address (struct frame_info *this_frame,
 				    void **this_prologue_cache)
 {
   struct alpha_heuristic_unwind_cache *info
-    = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
+    = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
 
   return info->vfp;
 }
@@ -1244,11 +1225,11 @@ reinit_frame_cache_sfunc (char *args, in
    breakpoint.  */
 
 static struct frame_id
-alpha_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+alpha_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
   ULONGEST base;
-  base = frame_unwind_register_unsigned (next_frame, ALPHA_SP_REGNUM);
-  return frame_id_build (base, frame_pc_unwind (next_frame));
+  base = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
+  return frame_id_build (base, get_frame_pc (this_frame));
 }
 
 static CORE_ADDR
@@ -1583,7 +1564,7 @@ alpha_gdbarch_init (struct gdbarch_info 
   set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
 
   /* Methods for saving / extracting a dummy frame's ID.  */
-  set_gdbarch_unwind_dummy_id (gdbarch, alpha_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, alpha_dummy_id);
 
   /* Return the unwound PC value.  */
   set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
@@ -1608,8 +1589,8 @@ alpha_gdbarch_init (struct gdbarch_info 
   if (tdep->jb_pc >= 0)
     set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
 
-  frame_unwind_append_sniffer (gdbarch, alpha_sigtramp_frame_sniffer);
-  frame_unwind_append_sniffer (gdbarch, alpha_heuristic_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &alpha_sigtramp_frame_unwind);
+  frame_unwind_append_unwinder (gdbarch, &alpha_heuristic_frame_unwind);
 
   frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
 
@@ -1619,7 +1600,7 @@ alpha_gdbarch_init (struct gdbarch_info 
 void
 alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 {
-  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+  dwarf2_append_unwinders (gdbarch);
   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 }
 

Re: [commit] update alpha-osf to new value-based unwinding

[Ulrich Weigand]

Joel Brobecker wrote:

> I just committed the following patch to update the alpha-osf port
> to the new value-based unwinding approach. I couldn't test it with
> the testsuite because, for some reason,  I can't make dejagnu/expect
> /tcl work anymore. So I used AdaCore's GDB testsuite instead.

If you have a way of testing on that platform, would you mind
testing the following patch?  This switches alpha-mdebug-tdep.c
to use trad-frame instead of relying SIZEOF_FRAME_SAVED_REGS;
if this is in, we can finally get rid of that macro ...

Thanks,
Ulrich


ChangeLog:

	* alpha-mdebug-tdep.c: Include "trad-frame.h".
	(struct alpha_mdebug_unwind_cache): Change type of SAVED_REGS to
	struct trad_frame_saved_reg *.
	(alpha_mdebug_frame_unwind_cache): Allocate SAVED_REGS using
	trad_frame_alloc_saved_regs.  Update accesses.  Record previous
	value of SP as being vfp.
	(alpha_mdebug_frame_prev_register): Use trad_frame_get_prev_register.
	* Makefile.in (alpha-mdebug-tdep.o): Update dependencies.


diff -urNp gdb-orig/gdb/alpha-mdebug-tdep.c gdb-head/gdb/alpha-mdebug-tdep.c
--- gdb-orig/gdb/alpha-mdebug-tdep.c	2008-05-16 22:36:17.000000000 +0200
+++ gdb-head/gdb/alpha-mdebug-tdep.c	2008-05-16 23:55:38.000000000 +0200
@@ -26,6 +26,7 @@
 #include "block.h"
 #include "gdb_assert.h"
 #include "gdb_string.h"
+#include "trad-frame.h"
 
 #include "alpha-tdep.h"
 #include "mdebugread.h"
@@ -170,7 +171,7 @@ struct alpha_mdebug_unwind_cache
 {
   struct mdebug_extra_func_info *proc_desc;
   CORE_ADDR vfp;
-  CORE_ADDR *saved_regs;
+  struct trad_frame_saved_reg *saved_regs;
 };
 
 /* Extract all of the information about the frame from PROC_DESC
@@ -201,7 +202,7 @@ alpha_mdebug_frame_unwind_cache (struct 
   info->proc_desc = proc_desc;
   gdb_assert (proc_desc != NULL);
 
-  info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
+  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
   /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET.  */
   vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
@@ -221,14 +222,14 @@ alpha_mdebug_frame_unwind_cache (struct 
       /* Clear bit for RA so we don't save it again later. */
       mask &= ~(1 << returnreg);
 
-      info->saved_regs[returnreg] = reg_position;
+      info->saved_regs[returnreg].addr = reg_position;
       reg_position += 8;
     }
 
   for (ireg = 0; ireg <= 31; ++ireg)
     if (mask & (1 << ireg))
       {
-	info->saved_regs[ireg] = reg_position;
+	info->saved_regs[ireg].addr = reg_position;
 	reg_position += 8;
       }
 
@@ -238,10 +239,15 @@ alpha_mdebug_frame_unwind_cache (struct 
   for (ireg = 0; ireg <= 31; ++ireg)
     if (mask & (1 << ireg))
       {
-	info->saved_regs[ALPHA_FP0_REGNUM + ireg] = reg_position;
+	info->saved_regs[ALPHA_FP0_REGNUM + ireg].addr = reg_position;
 	reg_position += 8;
       }
 
+  /* The stack pointer of the previous frame is computed by popping
+     the current stack frame.  */
+  if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
+   trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, vfp);
+
   return info;
 }
 
@@ -274,19 +280,7 @@ alpha_mdebug_frame_prev_register (struct
   if (regnum == ALPHA_PC_REGNUM)
     regnum = PROC_PC_REG (info->proc_desc);
   
-  /* For all registers known to be saved in the current frame, 
-     do the obvious and pull the value out.  */
-  if (info->saved_regs[regnum])
-    return frame_unwind_got_memory (this_frame, regnum,
-                                    info->saved_regs[regnum]);
-
-  /* The stack pointer of the previous frame is computed by popping
-     the current stack frame.  */
-  if (regnum == ALPHA_SP_REGNUM)
-    return frame_unwind_got_constant (this_frame, regnum, info->vfp);
-
-  /* Otherwise assume the next frame has the same register value.  */
-    return frame_unwind_got_register (this_frame, regnum, regnum);
+  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 }
 
 static int
diff -urNp gdb-orig/gdb/Makefile.in gdb-head/gdb/Makefile.in
--- gdb-orig/gdb/Makefile.in	2008-05-16 22:36:17.000000000 +0200
+++ gdb-head/gdb/Makefile.in	2008-05-16 23:52:56.000000000 +0200
@@ -1862,8 +1862,8 @@ alpha-linux-tdep.o: alpha-linux-tdep.c $
 	$(regcache_h) $(alpha_tdep_h)
 alpha-mdebug-tdep.o: alpha-mdebug-tdep.c $(defs_h) $(frame_h) \
 	$(frame_unwind_h) $(frame_base_h) $(symtab_h) $(gdbcore_h) \
-	$(block_h) $(gdb_assert_h) $(gdb_string_h) $(alpha_tdep_h) \
-	$(mdebugread_h)
+	$(block_h) $(gdb_assert_h) $(gdb_string_h) $(trad_frame_h) \
+	$(alpha_tdep_h) $(mdebugread_h)
 alpha-nat.o: alpha-nat.c $(defs_h) $(gdb_string_h) $(inferior_h) \
 	$(gdbcore_h) $(target_h) $(regcache_h) $(alpha_tdep_h) $(gregset_h)
 alphanbsd-tdep.o: alphanbsd-tdep.c $(defs_h) $(frame_h) $(gdbcore_h) \
-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [commit] update alpha-osf to new value-based unwinding

[Joel Brobecker]

Hi Ulrich,

> If you have a way of testing on that platform, would you mind
> testing the following patch?  This switches alpha-mdebug-tdep.c
> to use trad-frame instead of relying SIZEOF_FRAME_SAVED_REGS;
> if this is in, we can finally get rid of that macro ...

Nice! Sorry for my late reply, but the machine where I built
everything had a HD failure, and so I had to redo everything
from scratch on another machine. Since our Tru64 machines are
not exactly race cars....

> 	* alpha-mdebug-tdep.c: Include "trad-frame.h".
> 	(struct alpha_mdebug_unwind_cache): Change type of SAVED_REGS to
> 	struct trad_frame_saved_reg *.
> 	(alpha_mdebug_frame_unwind_cache): Allocate SAVED_REGS using
> 	trad_frame_alloc_saved_regs.  Update accesses.  Record previous
> 	value of SP as being vfp.
> 	(alpha_mdebug_frame_prev_register): Use trad_frame_get_prev_register.
> 	* Makefile.in (alpha-mdebug-tdep.o): Update dependencies.

According to our testsuite, there was no regression found.
I think that shows that the changes are sane.

-- 
Joel

Re: [commit] update alpha-osf to new value-based unwinding

[Ulrich Weigand]

Hi Joel,

> > 	* alpha-mdebug-tdep.c: Include "trad-frame.h".
> > 	(struct alpha_mdebug_unwind_cache): Change type of SAVED_REGS to
> > 	struct trad_frame_saved_reg *.
> > 	(alpha_mdebug_frame_unwind_cache): Allocate SAVED_REGS using
> > 	trad_frame_alloc_saved_regs.  Update accesses.  Record previous
> > 	value of SP as being vfp.
> > 	(alpha_mdebug_frame_prev_register): Use trad_frame_get_prev_register.
> > 	* Makefile.in (alpha-mdebug-tdep.o): Update dependencies.
> 
> According to our testsuite, there was no regression found.
> I think that shows that the changes are sane.

Thanks for testing!   I've checked this in now.

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com