* alphafbsd-tdep.c: Update for unwinder changes.

	* alpha-linux-tdep.c: Likewise.
	* alphanbsd-tdep.c: Likewise.
	* alphaobsd-tdep.c: Likewise.
	* avr-tdep.c: Likewise.
	* cris-tdep.c: Likewise.
	* frv-linux-tdep.c: Likewise.
	* frv-tdep.c: Likewise.
	* h8300-tdep.c: Likewise.
	* hppa-linux-tdep.c: Likewise.
	* iq2000-tdep.c: Likewise.
	* m32c-tdep.c: Likewise.
	* m32r-linux-tdep.c: Likewise.
	* m32r-tdep.c: Likewise.
	* m68hc11-tdep.c: Likewise.
	* mep-tdep.c: Likewise.
	* mn10300-tdep.c: Likewise.
	* mt-tdep.c: Likewise.
	* score-tdep.c: Likewise.
	* sh64-tdep.c: Likewise.
	* sh-tdep.c: Likewise.
	* sparc64fbsd-tdep.c: Likewise.
	* sparc64nbsd-tdep.c: Likewise.
	* sparc64obsd-tdep.c: Likewise.
	* v850-tdep.c: Likewise.
	* vaxobsd-tdep.c: Likewise.
	* vax-tdep.c: Likewise.
	* xstormy16-tdep.c: Likewise.

1 files changed, 54 insertions, 53 deletions

diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index f765d443ef1..16bb2436546 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -774,10 +774,10 @@ m68hc11_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
    for it IS the sp for the next frame. */
 
 struct m68hc11_unwind_cache *
-m68hc11_frame_unwind_cache (struct frame_info *next_frame,
+m68hc11_frame_unwind_cache (struct frame_info *this_frame,
                             void **this_prologue_cache)
 {
-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   ULONGEST prev_sp;
   ULONGEST this_base;
   struct m68hc11_unwind_cache *info;
@@ -789,9 +789,9 @@ m68hc11_frame_unwind_cache (struct frame_info *next_frame,
 
   info = FRAME_OBSTACK_ZALLOC (struct m68hc11_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);
 
-  info->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
+  info->pc = get_frame_func (this_frame);
 
   info->size = 0;
   info->return_kind = m68hc11_get_return_insn (info->pc);
@@ -799,14 +799,14 @@ m68hc11_frame_unwind_cache (struct frame_info *next_frame,
   /* The SP was moved to the FP.  This indicates that a new frame
      was created.  Get THIS frame's FP value by unwinding it from
      the next frame.  */
-  this_base = frame_unwind_register_unsigned (next_frame, SOFT_FP_REGNUM);
+  this_base = get_frame_register_unsigned (this_frame, SOFT_FP_REGNUM);
   if (this_base == 0)
     {
       info->base = 0;
       return info;
     }
 
-  current_pc = frame_pc_unwind (next_frame);
+  current_pc = get_frame_pc (this_frame);
   if (info->pc != 0)
     m68hc11_scan_prologue (gdbarch, info->pc, current_pc, info);
 
@@ -815,7 +815,7 @@ m68hc11_frame_unwind_cache (struct frame_info *next_frame,
   if (info->sp_offset != (CORE_ADDR) -1)
     {
       info->saved_regs[HARD_PC_REGNUM].addr = info->sp_offset;
-      this_base = frame_unwind_register_unsigned (next_frame, HARD_SP_REGNUM);
+      this_base = get_frame_register_unsigned (this_frame, HARD_SP_REGNUM);
       prev_sp = this_base + info->sp_offset + 2;
       this_base += STACK_CORRECTION (gdbarch);
     }
@@ -874,18 +874,18 @@ m68hc11_frame_unwind_cache (struct frame_info *next_frame,
    frame.  This will be used to create a new GDB frame struct.  */
 
 static void
-m68hc11_frame_this_id (struct frame_info *next_frame,
+m68hc11_frame_this_id (struct frame_info *this_frame,
                        void **this_prologue_cache,
                        struct frame_id *this_id)
 {
   struct m68hc11_unwind_cache *info
-    = m68hc11_frame_unwind_cache (next_frame, this_prologue_cache);
+    = m68hc11_frame_unwind_cache (this_frame, this_prologue_cache);
   CORE_ADDR base;
   CORE_ADDR func;
   struct frame_id id;
 
   /* The FUNC is easy.  */
-  func = frame_func_unwind (next_frame, NORMAL_FRAME);
+  func = get_frame_func (this_frame);
 
   /* Hopefully the prologue analysis either correctly determined the
      frame's base (which is the SP from the previous frame), or set
@@ -898,67 +898,69 @@ m68hc11_frame_this_id (struct frame_info *next_frame,
   (*this_id) = id;
 }
 
-static void
-m68hc11_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 *
+m68hc11_frame_prev_register (struct frame_info *this_frame,
+                             void **this_prologue_cache, int regnum)
 {
+  struct value *value;
   struct m68hc11_unwind_cache *info
-    = m68hc11_frame_unwind_cache (next_frame, this_prologue_cache);
+    = m68hc11_frame_unwind_cache (this_frame, this_prologue_cache);
 
-  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
-				optimizedp, lvalp, addrp, realnump, bufferp);
+  value = trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 
-  if (regnum == HARD_PC_REGNUM)
+  /* Take into account the 68HC12 specific call (PC + page).  */
+  if (regnum == HARD_PC_REGNUM
+      && info->return_kind == RETURN_RTC
+      && USE_PAGE_REGISTER (get_frame_arch (this_frame)))
     {
-      /* Take into account the 68HC12 specific call (PC + page).  */
-      if (info->return_kind == RETURN_RTC
-          && *addrp >= 0x08000 && *addrp < 0x0c000
-          && USE_PAGE_REGISTER (get_frame_arch (next_frame)))
+      CORE_ADDR pc = value_as_long (value);
+      if (pc >= 0x08000 && pc < 0x0c000)
         {
-          int page_optimized;
-
           CORE_ADDR page;
 
-          trad_frame_get_prev_register (next_frame, info->saved_regs,
-					HARD_PAGE_REGNUM, &page_optimized,
-					0, &page, 0, 0);
-          *addrp -= 0x08000;
-          *addrp += ((page & 0x0ff) << 14);
-          *addrp += 0x1000000;
+	  release_value (value);
+	  value_free (value);
+
+	  value = trad_frame_get_prev_register (this_frame, info->saved_regs,
+						HARD_PAGE_REGNUM);
+	  page = value_as_long (value);
+	  release_value (value);
+	  value_free (value);
+
+          pc -= 0x08000;
+          pc += ((page & 0x0ff) << 14);
+          pc += 0x1000000;
+
+	  return frame_unwind_got_constant (this_frame, regnum, pc);
         }
     }
+
+  return value;
 }
 
 static const struct frame_unwind m68hc11_frame_unwind = {
   NORMAL_FRAME,
   m68hc11_frame_this_id,
-  m68hc11_frame_prev_register
+  m68hc11_frame_prev_register,
+  NULL,
+  default_frame_sniffer
 };
 
-const struct frame_unwind *
-m68hc11_frame_sniffer (struct frame_info *next_frame)
-{
-  return &m68hc11_frame_unwind;
-}
-
 static CORE_ADDR
-m68hc11_frame_base_address (struct frame_info *next_frame, void **this_cache)
+m68hc11_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
   struct m68hc11_unwind_cache *info
-    = m68hc11_frame_unwind_cache (next_frame, this_cache);
+    = m68hc11_frame_unwind_cache (this_frame, this_cache);
 
   return info->base;
 }
 
 static CORE_ADDR
-m68hc11_frame_args_address (struct frame_info *next_frame, void **this_cache)
+m68hc11_frame_args_address (struct frame_info *this_frame, void **this_cache)
 {
   CORE_ADDR addr;
   struct m68hc11_unwind_cache *info
-    = m68hc11_frame_unwind_cache (next_frame, this_cache);
+    = m68hc11_frame_unwind_cache (this_frame, this_cache);
 
   addr = info->base + info->size;
   if (info->return_kind == RETURN_RTC)
@@ -984,18 +986,17 @@ m68hc11_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
   return sp;
 }
 
-/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
-   dummy frame.  The frame ID's base needs to match the TOS value
-   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
-   breakpoint.  */
+/* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
+   frame.  The frame ID's base needs to match the TOS value saved by
+   save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint.  */
 
 static struct frame_id
-m68hc11_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+m68hc11_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
   ULONGEST tos;
-  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  CORE_ADDR pc = get_frame_pc (this_frame);
 
-  tos = frame_unwind_register_unsigned (next_frame, SOFT_FP_REGNUM);
+  tos = get_frame_register_unsigned (this_frame, SOFT_FP_REGNUM);
   tos += 2;
   return frame_id_build (tos, pc);
 }
@@ -1520,15 +1521,15 @@ m68hc11_gdbarch_init (struct gdbarch_info info,
   set_gdbarch_print_registers_info (gdbarch, m68hc11_print_registers_info);
 
   /* Hook in the DWARF CFI frame unwinder.  */
-  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+  dwarf2_append_unwinders (gdbarch);
 
-  frame_unwind_append_sniffer (gdbarch, m68hc11_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &m68hc11_frame_unwind);
   frame_base_set_default (gdbarch, &m68hc11_frame_base);
   
   /* Methods for saving / extracting a dummy frame's ID.  The ID's
      stack address must match the SP value returned by
      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
-  set_gdbarch_unwind_dummy_id (gdbarch, m68hc11_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, m68hc11_dummy_id);
 
   /* Return the unwound PC value.  */
   set_gdbarch_unwind_pc (gdbarch, m68hc11_unwind_pc);