2004-02-17 Ulrich Weigand <Ulrich.Weigand@de.ibm.com>

	Committed by Jim Blandy  <jimb@redhat.com>.

	* s390-tdep.c: Include "trad-frame.h", "frame-base.h", and
	"frame-unwind.h".
	(s390_readinstruction): Reformat.  Use read_memory_nobpt.
	(GDB_TARGET_IS_ESAME, S390_GPR_SIZE, S390_FPR_SIZE): Remove.
	(S390_SYSCALL_OPCODE, S390_SYSCALL_SIZE): Remove.
	(S390_SIGCONTEXT_SREGS_OFFSET, S390X_SIGCONTEXT_SREGS_OFFSET,
	S390_SIGREGS_FP0_OFFSET, S390X_SIGREGS_FP0_OFFSET,
	S390_UC_MCONTEXT_OFFSET, S390X_UC_MCONTEXT_OFFSET,
	S390_SIGNAL_FRAMESIZE,
	s390_NR_sigreturn, s390_NR_rt_sigreturn): Remove.
	(struct frame_extra_info): Remove.
	(s390_memset_extra_info): Remove.
	(op_*, op1_*, op2_* enums): Add several new opcodes.
	(is_rse): Renamed to ...
	(is_rsy): ... this.  Support long displacements.
	(is_rxe): Renamed to ...
	(is_rxy): ... this.  Support long displacements.
	(compute_x_addr): Support long displacements.
	(struct s390_prologue_data): New data type.
	(s390_on_stack): Change API to use struct s390_prologue_data.
	(s390_store): Reimplement.
	(s390_load): New function.
	(s390_get_signal_frame_info): Remove.
	(s390_get_frame_info): Remove, replace by ...
	(s390_analyze_prolog): ... this new function.
	(s390_check_function_end): Remove.
	(s390_function_start): Remove.
	(s390_frameless_function_invokation): Remove.
	(s390_is_sigreturn): Remove.
	(s390_init_frame_pc_first): Remove.
	(s390_init_frame_extra_info): Remove.
	(s390_frame_init_saved_regs): Remove.
	(s390_frame_saved_pc_nofix): Remove.
	(s390_frame_saved_pc): Remove.
	(s390_frame_chain): Remove.
	(s390_fp_regnum, s390_read_fp): Remove.
	(s390_pop_frame_regular, s390_pop_frame): Remove.
	(s390_saved_pc_after_call): Remove.
	(s390_skip_prologue): Reimplement.
	(s390_in_function_epilogue_p): Support long displacements.
	(struct s390_unwind_cache): New data structure.
	(s390_frame_unwind_cache): New function.
	(s390_prologue_frame_unwind_cache): Likewise.
	(s390_backchain_frame_unwind_cache): Likewise.
	(s390_frame_this_id, s390_frame_prev_register): Likewise.
	(s390_frame_unwind): Define.
	(s390_frame_sniffer): New function.
	(struct s390_pltstub_unwind_cache): New data structure.
	(s390_pltstub_frame_unwind_cache): New function.
	(s390_pltstub_frame_this_id): Likewise.
	(s390_pltstub_frame_prev_register): Likewise.
	(s390_pltstub_frame_unwind): Define.
	(s390_pltstub_frame_sniffer): New function.
	(struct s390_sigtramp_unwind_cache): New data structure.
	(s390_sigtramp_frame_unwind_cache): New function.
	(s390_sigtramp_frame_this_id): Likewise.
	(s390_sigtramp_frame_prev_register): Likewise.
	(s390_sigtramp_frame_unwind): Define.
	(s390_sigtramp_frame_sniffer): New function.
	(s390_frame_base_address, s390_local_base_address): New functions.
	(s390_frame_base): Define.
	(s390_unwind_pc, s390_unwind_sp): New function.
	(s390_push_dummy_call): Use new frame base location.
	(s390_unwind_dummy_id): Likewise.
	(s390_gdbarch_init): Remove calls to:
	set_gdbarch_frameless_function_invocation,
	set_gdbarch_deprecated_init_frame_pc,
	set_gdbarch_deprecated_frame_chain,
	set_gdbarch_deprecated_frame_init_saved_regs,
	set_gdbarch_deprecated_pop_frame,
	set_gdbarch_deprecated_init_extra_frame_info,
	set_gdbarch_deprecated_init_frame_pc_first,
	set_gdbarch_deprecated_target_read_fp,
	set_gdbarch_deprecated_frame_saved_pc,
	set_gdbarch_deprecated_saved_pc_after_call,
	set_gdbarch_deprecated_fp_regnum.
	Add calls to:
	set_gdbarch_in_solib_call_trampoline,
	frame_unwind_append_sniffer,
	frame_base_set_default,
	set_gdbarch_unwind_pc,
	set_gdbarch_unwind_sp.
	* Makefile.in (s390-tdep.o): Update dependencies.

1 files changed, 949 insertions, 992 deletions

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index f55564e..227213f 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -35,6 +35,9 @@
 #include "../bfd/bfd.h"
 #include "floatformat.h"
 #include "regcache.h"
+#include "trad-frame.h"
+#include "frame-base.h"
+#include "frame-unwind.h"
 #include "reggroups.h"
 #include "regset.h"
 #include "value.h"
@@ -472,72 +475,6 @@ s390_regset_from_core_section (struct gdbarch *gdbarch,
 }
 
 
-#define GDB_TARGET_IS_ESAME (TARGET_ARCHITECTURE->mach == bfd_mach_s390_64)
-#define S390_GPR_SIZE      (GDB_TARGET_IS_ESAME ? 8 : 4)
-#define S390_FPR_SIZE      (8)
-#define S390_MAX_INSTR_SIZE (6)
-#define S390_SYSCALL_OPCODE (0x0a)
-#define S390_SYSCALL_SIZE   (2)
-#define S390_SIGCONTEXT_SREGS_OFFSET (8)
-#define S390X_SIGCONTEXT_SREGS_OFFSET (8)
-#define S390_SIGREGS_FP0_OFFSET       (144)
-#define S390X_SIGREGS_FP0_OFFSET      (216)
-#define S390_UC_MCONTEXT_OFFSET    (256)
-#define S390X_UC_MCONTEXT_OFFSET   (344)
-#define S390_SIGNAL_FRAMESIZE  (GDB_TARGET_IS_ESAME ? 160:96)
-#define s390_NR_sigreturn          119
-#define s390_NR_rt_sigreturn       173
-
-
-
-struct frame_extra_info
-{
-  int initialised;
-  int good_prologue;
-  CORE_ADDR function_start;
-  CORE_ADDR skip_prologue_function_start;
-  CORE_ADDR saved_pc_valid;
-  CORE_ADDR saved_pc;
-  CORE_ADDR sig_fixed_saved_pc_valid;
-  CORE_ADDR sig_fixed_saved_pc;
-  CORE_ADDR frame_pointer_saved_pc;	/* frame pointer needed for alloca */
-  CORE_ADDR stack_bought_valid;
-  CORE_ADDR stack_bought;	/* amount we decrement the stack pointer by */
-  CORE_ADDR sigcontext;
-};
-
-
-static CORE_ADDR s390_frame_saved_pc_nofix (struct frame_info *fi);
-
-static int
-s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
-{
-  int instrlen;
-
-  static int s390_instrlen[] = {
-    2,
-    4,
-    4,
-    6
-  };
-  if (target_read_memory (at, &instr[0], 2))
-    return -1;
-  instrlen = s390_instrlen[instr[0] >> 6];
-  if (instrlen > 2)
-    {
-      if (target_read_memory (at + 2, &instr[2], instrlen - 2))
-        return -1;
-    }
-  return instrlen;
-}
-
-static void
-s390_memset_extra_info (struct frame_extra_info *fextra_info)
-{
-  memset (fextra_info, 0, sizeof (struct frame_extra_info));
-}
-
-
 /* Prologue analysis.  */
 
 /* When we analyze a prologue, we're really doing 'abstract
@@ -929,32 +866,72 @@ pv_is_array_ref (struct prologue_value *addr,
    op1_* and op2_* enums.  */
 enum
   {
-    op1_aghi = 0xa7,   op2_aghi = 0xb,
-    op1_ahi  = 0xa7,   op2_ahi  = 0xa,
-    op_ar    = 0x1a,
-    op_basr  = 0x0d,
-    op1_bras = 0xa7,   op2_bras = 0x5,
-    op_l     = 0x58,
-    op_la    = 0x41,
-    op1_larl = 0xc0,   op2_larl = 0x0,
-    op_lgr   = 0xb904,
-    op1_lghi = 0xa7,   op2_lghi = 0x9,
-    op1_lhi  = 0xa7,   op2_lhi  = 0x8,
+    op1_lhi  = 0xa7,   op2_lhi  = 0x08,
+    op1_lghi = 0xa7,   op2_lghi = 0x09,
     op_lr    = 0x18,
-    op_nr    = 0x14,
-    op_ngr   = 0xb980,
-    op_s     = 0x5b,
+    op_lgr   = 0xb904,
+    op_l     = 0x58,
+    op1_ly   = 0xe3,   op2_ly   = 0x58,
+    op1_lg   = 0xe3,   op2_lg   = 0x04,
+    op_lm    = 0x98,
+    op1_lmy  = 0xeb,   op2_lmy  = 0x98,
+    op1_lmg  = 0xeb,   op2_lmg  = 0x04,
     op_st    = 0x50,
-    op_std   = 0x60,
+    op1_sty  = 0xe3,   op2_sty  = 0x50,
     op1_stg  = 0xe3,   op2_stg  = 0x24,
+    op_std   = 0x60,
     op_stm   = 0x90,
+    op1_stmy = 0xeb,   op2_stmy = 0x90,
     op1_stmg = 0xeb,   op2_stmg = 0x24,
-    op_lm    = 0x98,
-    op1_lmg  = 0xeb,   op2_lmg  = 0x04,
-    op_svc   = 0x0a,
+    op1_aghi = 0xa7,   op2_aghi = 0x0b,
+    op1_ahi  = 0xa7,   op2_ahi  = 0x0a,
+    op_ar    = 0x1a,
+    op_agr   = 0xb908,
+    op_a     = 0x5a,
+    op1_ay   = 0xe3,   op2_ay   = 0x5a,
+    op1_ag   = 0xe3,   op2_ag   = 0x08,
+    op_sr    = 0x1b,
+    op_sgr   = 0xb909,
+    op_s     = 0x5b,
+    op1_sy   = 0xe3,   op2_sy   = 0x5b,
+    op1_sg   = 0xe3,   op2_sg   = 0x09,
+    op_nr    = 0x14,
+    op_ngr   = 0xb980,
+    op_la    = 0x41,
+    op1_lay  = 0xe3,   op2_lay  = 0x71,
+    op1_larl = 0xc0,   op2_larl = 0x00,
+    op_basr  = 0x0d,
+    op_bas   = 0x4d,
+    op_bcr   = 0x07,
+    op_bc    = 0x0d,
+    op1_bras = 0xa7,   op2_bras = 0x05,
+    op1_brasl= 0xc0,   op2_brasl= 0x05,
+    op1_brc  = 0xa7,   op2_brc  = 0x04,
+    op1_brcl = 0xc0,   op2_brcl = 0x04,
   };
 
 
+/* Read a single instruction from address AT.  */
+
+#define S390_MAX_INSTR_SIZE 6
+static int
+s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
+{
+  static int s390_instrlen[] = { 2, 4, 4, 6 };
+  int instrlen;
+
+  if (read_memory_nobpt (at, &instr[0], 2))
+    return -1;
+  instrlen = s390_instrlen[instr[0] >> 6];
+  if (instrlen > 2)
+    {
+      if (read_memory_nobpt (at + 2, &instr[2], instrlen - 2))
+        return -1;
+    }
+  return instrlen;
+}
+
+
 /* The functions below are for recognizing and decoding S/390
    instructions of various formats.  Each of them checks whether INSN
    is an instruction of the given format, with the specified opcodes.
@@ -1051,17 +1028,18 @@ is_rs (bfd_byte *insn, int op,
 
 
 static int
-is_rse (bfd_byte *insn, int op1, int op2,
+is_rsy (bfd_byte *insn, int op1, int op2,
         unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
 {
   if (insn[0] == op1
-      /* Yes, insn[5].  insn[4] is unused.  */
       && insn[5] == op2)
     {
       *r1 = (insn[1] >> 4) & 0xf;
       *r3 = insn[1] & 0xf;
       *b2 = (insn[2] >> 4) & 0xf;
-      *d2 = ((insn[2] & 0xf) << 8) | insn[3];
+      /* The 'long displacement' is a 20-bit signed integer.  */
+      *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12)) 
+		^ 0x80000) - 0x80000;
       return 1;
     }
   else
@@ -1087,17 +1065,18 @@ is_rx (bfd_byte *insn, int op,
 
 
 static int
-is_rxe (bfd_byte *insn, int op1, int op2,
+is_rxy (bfd_byte *insn, int op1, int op2,
         unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
 {
   if (insn[0] == op1
-      /* Yes, insn[5].  insn[4] is unused.  */
       && insn[5] == op2)
     {
       *r1 = (insn[1] >> 4) & 0xf;
       *x2 = insn[1] & 0xf;
       *b2 = (insn[2] >> 4) & 0xf;
-      *d2 = ((insn[2] & 0xf) << 8) | insn[3];
+      /* The 'long displacement' is a 20-bit signed integer.  */
+      *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12)) 
+		^ 0x80000) - 0x80000;
       return 1;
     }
   else
@@ -1109,7 +1088,7 @@ is_rxe (bfd_byte *insn, int op1, int op2,
 
         L R1, D2(X2, B2)
 
-   Here, X2 and B2 are registers, and D2 is an unsigned 12-bit
+   Here, X2 and B2 are registers, and D2 is a signed 20-bit
    constant; the effective address is the sum of all three.  If either
    X2 or B2 are zero, then it doesn't contribute to the sum --- this
    means that r0 can't be used as either X2 or B2.
@@ -1119,7 +1098,7 @@ is_rxe (bfd_byte *insn, int op1, int op2,
 static void
 compute_x_addr (struct prologue_value *addr, 
                 struct prologue_value *gpr,
-                unsigned int d2, unsigned int x2, unsigned int b2)
+                int d2, unsigned int x2, unsigned int b2)
 {
   /* We can't just add stuff directly in addr; it might alias some of
      the registers we need to read.  */
@@ -1142,27 +1121,41 @@ compute_x_addr (struct prologue_value *addr,
 #define S390_NUM_GPRS 16
 #define S390_NUM_FPRS 16
 
+struct s390_prologue_data {
+
+  /* The size of a GPR or FPR.  */
+  int gpr_size;
+  int fpr_size;
+
+  /* The general-purpose registers.  */
+  struct prologue_value gpr[S390_NUM_GPRS];
+
+  /* The floating-point registers.  */
+  struct prologue_value fpr[S390_NUM_FPRS];
+
+  /* The register spill stack slots in the caller's frame ---
+     general-purpose registers r2 through r15, and floating-point
+     registers.  spill[i] is where gpr i+2 gets spilled;
+     spill[(14, 15, 16, 17)] is where (f0, f2, f4, f6) get spilled.  */
+  struct prologue_value spill[S390_NUM_SPILL_SLOTS];
+
+  /* The value of the back chain slot.  This is only valid if the stack
+     pointer is known to be less than its original value --- that is,
+     if we have indeed allocated space on the stack.  */
+  struct prologue_value back_chain;
+};
+
 
 /* If the SIZE bytes at ADDR are a stack slot we're actually tracking,
    return pv_definite_yes and set *STACK to point to the slot.  If
    we're sure that they are not any of our stack slots, then return
    pv_definite_no.  Otherwise, return pv_maybe.
-   - GPR is an array indexed by GPR number giving the current values
-     of the general-purpose registers.
-   - SPILL is an array tracking the spill area of the caller's frame;
-     SPILL[i] is the i'th spill slot.  The spill slots are designated
-     for r2 -- r15, and then f0, f2, f4, and f6.
-   - BACK_CHAIN is the value of the back chain slot; it's only valid
-     when the current frame actually has some space for a back chain
-     slot --- that is, when the current value of the stack pointer
-     (according to GPR) is at least S390_STACK_FRAME_OVERHEAD bytes
-     less than its original value.  */
+
+   DATA describes our current state (registers and stack slots).  */
 static enum pv_boolean
 s390_on_stack (struct prologue_value *addr,
                CORE_ADDR size,
-               struct prologue_value *gpr,
-               struct prologue_value *spill, 
-               struct prologue_value *back_chain,
+	       struct s390_prologue_data *data,
                struct prologue_value **stack)
 {
   struct prologue_value gpr_spill_addr;
@@ -1172,9 +1165,9 @@ s390_on_stack (struct prologue_value *addr,
   enum pv_boolean b;
 
   /* Construct the addresses of the spill arrays and the back chain.  */
-  pv_set_to_register (&gpr_spill_addr, S390_SP_REGNUM, 2 * S390_GPR_SIZE);
-  pv_set_to_register (&fpr_spill_addr, S390_SP_REGNUM, 16 * S390_GPR_SIZE);
-  back_chain_addr = gpr[S390_SP_REGNUM - S390_R0_REGNUM];
+  pv_set_to_register (&gpr_spill_addr, S390_SP_REGNUM, 2 * data->gpr_size);
+  pv_set_to_register (&fpr_spill_addr, S390_SP_REGNUM, 16 * data->gpr_size);
+  back_chain_addr = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
 
   /* We have to check for GPR and FPR references using two separate
      calls to pv_is_array_ref, since the GPR and FPR spill slots are
@@ -1182,20 +1175,20 @@ s390_on_stack (struct prologue_value *addr,
      isn't really an array.)  */
 
   /* Was it a reference to the GPR spill array?  */
-  b = pv_is_array_ref (addr, size, &gpr_spill_addr, 14, S390_GPR_SIZE, &i);
+  b = pv_is_array_ref (addr, size, &gpr_spill_addr, 14, data->gpr_size, &i);
   if (b == pv_definite_yes)
     {
-      *stack = &spill[i];
+      *stack = &data->spill[i];
       return pv_definite_yes;
     }
   if (b == pv_maybe)
     return pv_maybe;
 
   /* Was it a reference to the FPR spill array?  */
-  b = pv_is_array_ref (addr, size, &fpr_spill_addr, 4, S390_FPR_SIZE, &i);
+  b = pv_is_array_ref (addr, size, &fpr_spill_addr, 4, data->fpr_size, &i);
   if (b == pv_definite_yes)
     {
-      *stack = &spill[14 + i];
+      *stack = &data->spill[14 + i];
       return pv_definite_yes;
     }
   if (b == pv_maybe)
@@ -1204,10 +1197,10 @@ s390_on_stack (struct prologue_value *addr,
   /* Was it a reference to the back chain?
      This isn't quite right.  We ought to check whether we have
      actually allocated any new frame at all.  */
-  b = pv_is_array_ref (addr, size, &back_chain_addr, 1, S390_GPR_SIZE, &i);
+  b = pv_is_array_ref (addr, size, &back_chain_addr, 1, data->gpr_size, &i);
   if (b == pv_definite_yes)
     {
-      *stack = back_chain;
+      *stack = &data->back_chain;
       return pv_definite_yes;
     }
   if (b == pv_maybe)
@@ -1218,76 +1211,90 @@ s390_on_stack (struct prologue_value *addr,
 }
 
 
-/* Do a SIZE-byte store of VALUE to ADDR.  GPR, SPILL, and BACK_CHAIN,
-   and the return value are as described for s390_on_stack, above.
-   Note that, when this returns pv_maybe, we have to assume that all
-   of our memory now contains unknown values.  */
-static enum pv_boolean
+/* Do a SIZE-byte store of VALUE to ADDR.  */
+static void
 s390_store (struct prologue_value *addr,
             CORE_ADDR size,
             struct prologue_value *value,
-            struct prologue_value *gpr,
-            struct prologue_value *spill, 
-            struct prologue_value *back_chain)
+	    struct s390_prologue_data *data)
 {
   struct prologue_value *stack;
-  enum pv_boolean on_stack
-    = s390_on_stack (addr, size, gpr, spill, back_chain, &stack);
 
-  if (on_stack == pv_definite_yes)
-    *stack = *value;
+  /* We can do it if it's definitely a reference to something on the stack.  */
+  if (s390_on_stack (addr, size, data, &stack) == pv_definite_yes)
+    {
+      *stack = *value;
+      return;
+    }
 
-  return on_stack;
+  /* Note: If s390_on_stack returns pv_maybe, you might think we should
+     forget our cached values, as any of those might have been hit.
+
+     However, we make the assumption that --since the fields we track
+     are save areas private to compiler, and never directly exposed to 
+     the user-- every access to our data is explicit.  Hence, every 
+     memory access we cannot follow can't hit our data.  */
 }
-            
 
-/* The current frame looks like a signal delivery frame: the first
-   instruction is an 'svc' opcode.  If the next frame is a signal
-   handler's frame, set FI's saved register map to point into the
-   signal context structure.  */
+/* Do a SIZE-byte load from ADDR into VALUE.  */
 static void
-s390_get_signal_frame_info (struct frame_info *fi)
+s390_load (struct prologue_value *addr,
+	   CORE_ADDR size,
+	   struct prologue_value *value,
+	   struct s390_prologue_data *data)
 {
-  struct frame_info *next_frame = get_next_frame (fi);
+  struct prologue_value *stack;
 
-  if (next_frame
-      && get_frame_extra_info (next_frame)
-      && get_frame_extra_info (next_frame)->sigcontext)
+  /* If it's a load from an in-line constant pool, then we can
+     simulate that, under the assumption that the code isn't
+     going to change between the time the processor actually
+     executed it creating the current frame, and the time when
+     we're analyzing the code to unwind past that frame.  */
+  if (addr->kind == pv_constant)
     {
-      /* We're definitely backtracing from a signal handler.  */
-      CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
-      CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
-                                 + DEPRECATED_REGISTER_BYTE (S390_R0_REGNUM));
-      int reg;
-
-      for (reg = 0; reg < S390_NUM_GPRS; reg++)
-        {
-          saved_regs[S390_R0_REGNUM + reg] = save_reg_addr;
-          save_reg_addr += S390_GPR_SIZE;
-        }
+      struct section_table *secp;
+      secp = target_section_by_addr (&current_target, addr->k);
+      if (secp != NULL
+          && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
+              & SEC_READONLY))
+	{
+          pv_set_to_constant (value, read_memory_integer (addr->k, size));
+	  return;
+	}
+    }
 
-      save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
-                       + (GDB_TARGET_IS_ESAME ? S390X_SIGREGS_FP0_OFFSET :
-                          S390_SIGREGS_FP0_OFFSET));
-      for (reg = 0; reg < S390_NUM_FPRS; reg++)
-        {
-          saved_regs[S390_F0_REGNUM + reg] = save_reg_addr;
-          save_reg_addr += S390_FPR_SIZE;
-        }
+  /* If it's definitely a reference to something on the stack, 
+     we can do that.  */
+  if (s390_on_stack (addr, size, data, &stack) == pv_definite_yes)
+    {
+      *value = *stack;
+      return;
     }
-}
 
+  /* Otherwise, we don't know the value.  */
+  pv_set_to_unknown (value);
+}
+            
 
-static int
-s390_get_frame_info (CORE_ADDR start_pc,
-                     struct frame_extra_info *fextra_info,
-                     struct frame_info *fi,
-                     int init_extra_info)
+/* Analyze the prologue of the function starting at START_PC,
+   continuing at most until CURRENT_PC.  Initialize DATA to
+   hold all information we find out about the state of the registers
+   and stack slots.  Return the address of the instruction after
+   the last one that changed the SP, FP, or back chain; or zero
+   on error.  */
+static CORE_ADDR
+s390_analyze_prologue (struct gdbarch *gdbarch,
+		       CORE_ADDR start_pc,
+		       CORE_ADDR current_pc,
+		       struct s390_prologue_data *data)
 {
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+
   /* Our return value:
-     zero if we were able to read all the instructions we wanted, or
-     -1 if we got an error trying to read memory.  */
-  int result = 0;
+     The address of the instruction after the last one that changed
+     the SP, FP, or back chain;  zero if we got an error trying to 
+     read memory.  */
+  CORE_ADDR result = start_pc;
 
   /* The current PC for our abstract interpretation.  */
   CORE_ADDR pc;
@@ -1295,55 +1302,38 @@ s390_get_frame_info (CORE_ADDR start_pc,
   /* The address of the next instruction after that.  */
   CORE_ADDR next_pc;
   
-  /* The general-purpose registers.  */
-  struct prologue_value gpr[S390_NUM_GPRS];
-
-  /* The floating-point registers.  */
-  struct prologue_value fpr[S390_NUM_FPRS];
-
-  /* The register spill stack slots in the caller's frame ---
-     general-purpose registers r2 through r15, and floating-point
-     registers.  spill[i] is where gpr i+2 gets spilled;
-     spill[(14, 15, 16, 17)] is where (f0, f2, f4, f6) get spilled.  */
-  struct prologue_value spill[S390_NUM_SPILL_SLOTS];
-
-  /* The value of the back chain slot.  This is only valid if the stack
-     pointer is known to be less than its original value --- that is,
-     if we have indeed allocated space on the stack.  */
-  struct prologue_value back_chain;
-
-  /* The address of the instruction after the last one that changed
-     the SP, FP, or back chain.  */
-  CORE_ADDR after_last_frame_setup_insn = start_pc;
-
   /* Set up everything's initial value.  */
   {
     int i;
 
+    /* For the purpose of prologue tracking, we consider the GPR size to
+       be equal to the ABI word size, even if it is actually larger
+       (i.e. when running a 32-bit binary under a 64-bit kernel).  */
+    data->gpr_size = word_size;
+    data->fpr_size = 8;
+
     for (i = 0; i < S390_NUM_GPRS; i++)
-      pv_set_to_register (&gpr[i], S390_R0_REGNUM + i, 0);
+      pv_set_to_register (&data->gpr[i], S390_R0_REGNUM + i, 0);
 
     for (i = 0; i < S390_NUM_FPRS; i++)
-      pv_set_to_register (&fpr[i], S390_F0_REGNUM + i, 0);
+      pv_set_to_register (&data->fpr[i], S390_F0_REGNUM + i, 0);
 
     for (i = 0; i < S390_NUM_SPILL_SLOTS; i++)
-      pv_set_to_unknown (&spill[i]);
+      pv_set_to_unknown (&data->spill[i]);
 
-    pv_set_to_unknown (&back_chain);
+    pv_set_to_unknown (&data->back_chain);
   }
 
-  /* Start interpreting instructions, until we hit something we don't
-     know how to interpret.  (Ideally, we should stop at the frame's
-     real current PC, but at the moment, our callers don't give us
-     that info.)  */
-  for (pc = start_pc; ; pc = next_pc)
+  /* Start interpreting instructions, until we hit the frame's
+     current PC or the first branch instruction.  */
+  for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
     {
       bfd_byte insn[S390_MAX_INSTR_SIZE];
       int insn_len = s390_readinstruction (insn, pc);
 
       /* Fields for various kinds of instructions.  */
-      unsigned int b2, r1, r2, d2, x2, r3;
-      int i2;
+      unsigned int b2, r1, r2, x2, r3;
+      int i2, d2;
 
       /* The values of SP, FP, and back chain before this instruction,
          for detecting instructions that change them.  */
@@ -1352,182 +1342,94 @@ s390_get_frame_info (CORE_ADDR start_pc,
       /* If we got an error trying to read the instruction, report it.  */
       if (insn_len < 0)
         {
-          result = -1;
+          result = 0;
           break;
         }
 
       next_pc = pc + insn_len;
 
-      pre_insn_sp = gpr[S390_SP_REGNUM - S390_R0_REGNUM];
-      pre_insn_fp = gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
-      pre_insn_back_chain = back_chain;
-
-      /* A special case, first --- only recognized as the very first
-         instruction of the function, for signal delivery frames:
-         SVC i --- system call  */
-      if (pc == start_pc
-          && is_rr (insn, op_svc, &r1, &r2))
-        {
-          if (fi)
-            s390_get_signal_frame_info (fi);
-          break;
-        }
-        
-      /* AHI r1, i2 --- add halfword immediate */
-      else if (is_ri (insn, op1_ahi, op2_ahi, &r1, &i2))
-        pv_add_constant (&gpr[r1], i2);
+      pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
+      pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
+      pre_insn_back_chain = data->back_chain;
 
+      /* LHI r1, i2 --- load halfword immediate */
+      if (word_size == 4
+	  && is_ri (insn, op1_lhi, op2_lhi, &r1, &i2))
+        pv_set_to_constant (&data->gpr[r1], i2);
 
-      /* AGHI r1, i2 --- add halfword immediate (64-bit version) */
-      else if (GDB_TARGET_IS_ESAME
-               && is_ri (insn, op1_aghi, op2_aghi, &r1, &i2))
-        pv_add_constant (&gpr[r1], i2);
+      /* LGHI r1, i2 --- load halfword immediate (64-bit version) */
+      else if (word_size == 8
+	       && is_ri (insn, op1_lghi, op2_lghi, &r1, &i2))
+        pv_set_to_constant (&data->gpr[r1], i2);
 
-      /* AR r1, r2 -- add register */
-      else if (is_rr (insn, op_ar, &r1, &r2))
-        pv_add (&gpr[r1], &gpr[r1], &gpr[r2]);
+      /* LR r1, r2 --- load from register */
+      else if (word_size == 4
+	       && is_rr (insn, op_lr, &r1, &r2))
+        data->gpr[r1] = data->gpr[r2];
 
-      /* BASR r1, 0 --- branch and save
-         Since r2 is zero, this saves the PC in r1, but doesn't branch.  */
-      else if (is_rr (insn, op_basr, &r1, &r2)
-               && r2 == 0)
-        pv_set_to_constant (&gpr[r1], next_pc);
+      /* LGR r1, r2 --- load from register (64-bit version) */
+      else if (word_size == 8
+               && is_rre (insn, op_lgr, &r1, &r2))
+        data->gpr[r1] = data->gpr[r2];
 
-      /* BRAS r1, i2 --- branch relative and save */
-      else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
+      /* L r1, d2(x2, b2) --- load */
+      else if (word_size == 4
+	       && is_rx (insn, op_l, &r1, &d2, &x2, &b2))
         {
-          pv_set_to_constant (&gpr[r1], next_pc);
-          next_pc = pc + i2 * 2;
+          struct prologue_value addr;
 
-          /* We'd better not interpret any backward branches.  We'll
-             never terminate.  */
-          if (next_pc <= pc)
-            break;
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &data->gpr[r1], data);
         }
 
-      /* L r1, d2(x2, b2) --- load */
-      else if (is_rx (insn, op_l, &r1, &d2, &x2, &b2))
+      /* LY r1, d2(x2, b2) --- load (long-displacement version) */
+      else if (word_size == 4
+	       && is_rxy (insn, op1_ly, op2_ly, &r1, &d2, &x2, &b2))
         {
           struct prologue_value addr;
-          struct prologue_value *stack;
-
-          compute_x_addr (&addr, gpr, d2, x2, b2);
-
-          /* If it's a load from an in-line constant pool, then we can
-             simulate that, under the assumption that the code isn't
-             going to change between the time the processor actually
-             executed it creating the current frame, and the time when
-             we're analyzing the code to unwind past that frame.  */
-          if (addr.kind == pv_constant
-              && start_pc <= addr.k 
-              && addr.k < next_pc)
-            pv_set_to_constant (&gpr[r1], 
-                                read_memory_integer (addr.k, 4));
-
-          /* If it's definitely a reference to something on the stack, 
-             we can do that.  */
-          else if (s390_on_stack (&addr, 4, gpr, spill, &back_chain, &stack)
-                   == pv_definite_yes)
-            gpr[r1] = *stack;
-
-          /* Otherwise, we don't know the value.  */
-          else
-            pv_set_to_unknown (&gpr[r1]);
-        }
-
-      /* LA r1, d2(x2, b2) --- load address */
-      else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2))
-        compute_x_addr (&gpr[r1], gpr, d2, x2, b2);
-
-      /* LARL r1, i2 --- load address relative long */
-      else if (GDB_TARGET_IS_ESAME 
-               && is_ril (insn, op1_larl, op2_larl, &r1, &i2))
-        pv_set_to_constant (&gpr[r1], pc + i2 * 2);
-
-      /* LGR r1, r2 --- load from register */
-      else if (GDB_TARGET_IS_ESAME
-               && is_rre (insn, op_lgr, &r1, &r2))
-        gpr[r1] = gpr[r2];
 
-      /* LHI r1, i2 --- load halfword immediate */
-      else if (is_ri (insn, op1_lhi, op2_lhi, &r1, &i2))
-        pv_set_to_constant (&gpr[r1], i2);
-
-      /* LGHI r1, i2 --- load halfword immediate --- 64-bit version */
-      else if (is_ri (insn, op1_lghi, op2_lghi, &r1, &i2))
-        pv_set_to_constant (&gpr[r1], i2);
-
-      /* LR r1, r2 --- load from register */
-      else if (is_rr (insn, op_lr, &r1, &r2))
-        gpr[r1] = gpr[r2];
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &data->gpr[r1], data);
+        }
 
-      /* NGR r1, r2 --- logical and --- 64-bit version */
-      else if (GDB_TARGET_IS_ESAME
-               && is_rre (insn, op_ngr, &r1, &r2))
-        pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
+      /* LG r1, d2(x2, b2) --- load (64-bit version) */
+      else if (word_size == 8
+	       && is_rxy (insn, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
+        {
+          struct prologue_value addr;
 
-      /* NR r1, r2 --- logical and */
-      else if (is_rr (insn, op_nr, &r1, &r2))
-        pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 8, &data->gpr[r1], data);
+        }
 
-      /* NGR r1, r2 --- logical and --- 64-bit version */
-      else if (GDB_TARGET_IS_ESAME
-               && is_rre (insn, op_ngr, &r1, &r2))
-        pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
+      /* ST r1, d2(x2, b2) --- store */
+      else if (word_size == 4
+	       && is_rx (insn, op_st, &r1, &d2, &x2, &b2))
+        {
+          struct prologue_value addr;
 
-      /* NR r1, r2 --- logical and */
-      else if (is_rr (insn, op_nr, &r1, &r2))
-        pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_store (&addr, 4, &data->gpr[r1], data);
+        }
 
-      /* S r1, d2(x2, b2) --- subtract from memory */
-      else if (is_rx (insn, op_s, &r1, &d2, &x2, &b2))
+      /* STY r1, d2(x2, b2) --- store (long-displacement version) */
+      else if (word_size == 4
+	       && is_rxy (insn, op1_sty, op2_sty, &r1, &d2, &x2, &b2))
         {
           struct prologue_value addr;
-          struct prologue_value value;
-          struct prologue_value *stack;
-
-          compute_x_addr (&addr, gpr, d2, x2, b2);
-
-          /* If it's a load from an in-line constant pool, then we can
-             simulate that, under the assumption that the code isn't
-             going to change between the time the processor actually
-             executed it and the time when we're analyzing it.  */
-          if (addr.kind == pv_constant
-              && start_pc <= addr.k 
-              && addr.k < pc)
-            pv_set_to_constant (&value, read_memory_integer (addr.k, 4));
-
-          /* If it's definitely a reference to something on the stack,
-             we could do that.  */
-          else if (s390_on_stack (&addr, 4, gpr, spill, &back_chain, &stack)
-                   == pv_definite_yes)
-            value = *stack;
-
-          /* Otherwise, we don't know the value.  */
-          else
-            pv_set_to_unknown (&value);
-
-          pv_subtract (&gpr[r1], &gpr[r1], &value);
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_store (&addr, 4, &data->gpr[r1], data);
         }
 
-      /* ST r1, d2(x2, b2) --- store  */
-      else if (is_rx (insn, op_st, &r1, &d2, &x2, &b2))
+      /* STG r1, d2(x2, b2) --- store (64-bit version) */
+      else if (word_size == 8
+	       && is_rxy (insn, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
         {
           struct prologue_value addr;
 
-          compute_x_addr (&addr, gpr, d2, x2, b2);
-
-          /* The below really should be '4', not 'S390_GPR_SIZE'; this
-             instruction always stores 32 bits, regardless of the full
-             size of the GPR.  */
-          if (s390_store (&addr, 4, &gpr[r1], gpr, spill, &back_chain)
-              == pv_maybe)
-            /* If we can't be sure that it's *not* a store to
-               something we're tracing, then we would have to mark all
-               our memory as unknown --- after all, it *could* be a
-               store to any of them --- so we might as well just stop
-               interpreting.  */
-            break;
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_store (&addr, 8, &data->gpr[r1], data);
         }
 
       /* STD r1, d2(x2,b2) --- store floating-point register  */
@@ -1535,41 +1437,30 @@ s390_get_frame_info (CORE_ADDR start_pc,
         {
           struct prologue_value addr;
 
-          compute_x_addr (&addr, gpr, d2, x2, b2);
-
-          if (s390_store (&addr, 8, &fpr[r1], gpr, spill, &back_chain)
-              == pv_maybe)
-            /* If we can't be sure that it's *not* a store to
-               something we're tracing, then we would have to mark all
-               our memory as unknown --- after all, it *could* be a
-               store to any of them --- so we might as well just stop
-               interpreting.  */
-            break;
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+          s390_store (&addr, 8, &data->fpr[r1], data);
         }
 
-      /* STG r1, d2(x2, b2) --- 64-bit store */
-      else if (GDB_TARGET_IS_ESAME
-               && is_rxe (insn, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
+      /* STM r1, r3, d2(b2) --- store multiple */
+      else if (word_size == 4
+	       && is_rs (insn, op_stm, &r1, &r3, &d2, &b2))
         {
+          int regnum;
+          int offset;
           struct prologue_value addr;
 
-          compute_x_addr (&addr, gpr, d2, x2, b2);
-
-          /* The below really should be '8', not 'S390_GPR_SIZE'; this
-             instruction always stores 64 bits, regardless of the full
-             size of the GPR.  */
-          if (s390_store (&addr, 8, &gpr[r1], gpr, spill, &back_chain)
-              == pv_maybe)
-            /* If we can't be sure that it's *not* a store to
-               something we're tracing, then we would have to mark all
-               our memory as unknown --- after all, it *could* be a
-               store to any of them --- so we might as well just stop
-               interpreting.  */
-            break;
+          for (regnum = r1, offset = 0;
+               regnum <= r3;
+               regnum++, offset += 4)
+            {
+              compute_x_addr (&addr, data->gpr, d2 + offset, 0, b2);
+              s390_store (&addr, 4, &data->gpr[regnum], data);
+            }
         }
 
-      /* STM r1, r3, d2(b2) --- store multiple */
-      else if (is_rs (insn, op_stm, &r1, &r3, &d2, &b2))
+      /* STMY r1, r3, d2(b2) --- store multiple (long-displacement version) */
+      else if (word_size == 4
+	       && is_rsy (insn, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2))
         {
           int regnum;
           int offset;
@@ -1579,27 +1470,14 @@ s390_get_frame_info (CORE_ADDR start_pc,
                regnum <= r3;
                regnum++, offset += 4)
             {
-              compute_x_addr (&addr, gpr, d2 + offset, 0, b2);
-              
-              if (s390_store (&addr, 4, &gpr[regnum], gpr, spill, &back_chain)
-                  == pv_maybe)
-                /* If we can't be sure that it's *not* a store to
-                   something we're tracing, then we would have to mark all
-                   our memory as unknown --- after all, it *could* be a
-                   store to any of them --- so we might as well just stop
-                   interpreting.  */
-                break;
+              compute_x_addr (&addr, data->gpr, d2 + offset, 0, b2);
+              s390_store (&addr, 4, &data->gpr[regnum], data);
             }
-
-          /* If we left the loop early, we should stop interpreting
-             altogether.  */
-          if (regnum <= r3)
-            break;
         }
 
-      /* STMG r1, r3, d2(b2) --- store multiple, 64-bit */
-      else if (GDB_TARGET_IS_ESAME
-               && is_rse (insn, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
+      /* STMG r1, r3, d2(b2) --- store multiple (64-bit version) */
+      else if (word_size == 8
+	       && is_rsy (insn, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
         {
           int regnum;
           int offset;
@@ -1609,31 +1487,177 @@ s390_get_frame_info (CORE_ADDR start_pc,
                regnum <= r3;
                regnum++, offset += 8)
             {
-              compute_x_addr (&addr, gpr, d2 + offset, 0, b2);
-              
-              if (s390_store (&addr, 8, &gpr[regnum], gpr, spill, &back_chain)
-                  == pv_maybe)
-                /* If we can't be sure that it's *not* a store to
-                   something we're tracing, then we would have to mark all
-                   our memory as unknown --- after all, it *could* be a
-                   store to any of them --- so we might as well just stop
-                   interpreting.  */
-                break;
+              compute_x_addr (&addr, data->gpr, d2 + offset, 0, b2);
+              s390_store (&addr, 8, &data->gpr[regnum], data);
             }
+        }
+
+      /* AHI r1, i2 --- add halfword immediate */
+      else if (word_size == 4
+	       && is_ri (insn, op1_ahi, op2_ahi, &r1, &i2))
+        pv_add_constant (&data->gpr[r1], i2);
+
+      /* AGHI r1, i2 --- add halfword immediate (64-bit version) */
+      else if (word_size == 8
+               && is_ri (insn, op1_aghi, op2_aghi, &r1, &i2))
+        pv_add_constant (&data->gpr[r1], i2);
+
+      /* AR r1, r2 -- add register */
+      else if (word_size == 4
+	       && is_rr (insn, op_ar, &r1, &r2))
+        pv_add (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* AGR r1, r2 -- add register (64-bit version) */
+      else if (word_size == 8
+	       && is_rre (insn, op_agr, &r1, &r2))
+        pv_add (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* A r1, d2(x2, b2) -- add */
+      else if (word_size == 4
+	       && is_rx (insn, op_a, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &value, data);
+	
+	  pv_add (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* AY r1, d2(x2, b2) -- add (long-displacement version) */
+      else if (word_size == 4
+	       && is_rxy (insn, op1_ay, op2_ay, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &value, data);
+	
+	  pv_add (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* AG r1, d2(x2, b2) -- add (64-bit version) */
+      else if (word_size == 8
+	       && is_rxy (insn, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 8, &value, data);
+	
+	  pv_add (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* SR r1, r2 -- subtract register */
+      else if (word_size == 4
+	       && is_rr (insn, op_sr, &r1, &r2))
+        pv_subtract (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* SGR r1, r2 -- subtract register (64-bit version) */
+      else if (word_size == 8
+	       && is_rre (insn, op_sgr, &r1, &r2))
+        pv_subtract (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* S r1, d2(x2, b2) -- subtract */
+      else if (word_size == 4
+	       && is_rx (insn, op_s, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &value, data);
+	
+	  pv_subtract (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* SY r1, d2(x2, b2) -- subtract (long-displacement version) */
+      else if (word_size == 4
+	       && is_rxy (insn, op1_sy, op2_sy, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 4, &value, data);
+	
+	  pv_subtract (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* SG r1, d2(x2, b2) -- subtract (64-bit version) */
+      else if (word_size == 8
+	       && is_rxy (insn, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
+	{
+          struct prologue_value addr;
+          struct prologue_value value;
+
+          compute_x_addr (&addr, data->gpr, d2, x2, b2);
+	  s390_load (&addr, 8, &value, data);
+	
+	  pv_subtract (&data->gpr[r1], &data->gpr[r1], &value);
+	}
+
+      /* NR r1, r2 --- logical and */
+      else if (word_size == 4
+	       && is_rr (insn, op_nr, &r1, &r2))
+        pv_logical_and (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* NGR r1, r2 >--- logical and (64-bit version) */
+      else if (word_size == 8
+               && is_rre (insn, op_ngr, &r1, &r2))
+        pv_logical_and (&data->gpr[r1], &data->gpr[r1], &data->gpr[r2]);
+
+      /* LA r1, d2(x2, b2) --- load address */
+      else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2))
+        compute_x_addr (&data->gpr[r1], data->gpr, d2, x2, b2);
+
+      /* LAY r1, d2(x2, b2) --- load address (long-displacement version) */
+      else if (is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
+        compute_x_addr (&data->gpr[r1], data->gpr, d2, x2, b2);
+
+      /* LARL r1, i2 --- load address relative long */
+      else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
+        pv_set_to_constant (&data->gpr[r1], pc + i2 * 2);
+
+      /* BASR r1, 0 --- branch and save
+         Since r2 is zero, this saves the PC in r1, but doesn't branch.  */
+      else if (is_rr (insn, op_basr, &r1, &r2)
+               && r2 == 0)
+        pv_set_to_constant (&data->gpr[r1], next_pc);
+
+      /* BRAS r1, i2 --- branch relative and save */
+      else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
+        {
+          pv_set_to_constant (&data->gpr[r1], next_pc);
+          next_pc = pc + i2 * 2;
 
-          /* If we left the loop early, we should stop interpreting
-             altogether.  */
-          if (regnum <= r3)
+          /* We'd better not interpret any backward branches.  We'll
+             never terminate.  */
+          if (next_pc <= pc)
             break;
         }
 
+      /* Terminate search when hitting any other branch instruction.  */
+      else if (is_rr (insn, op_basr, &r1, &r2)
+	       || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
+	       || is_rr (insn, op_bcr, &r1, &r2)
+	       || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
+	       || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
+	       || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
+	       || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
+	break;
+
       else
         /* An instruction we don't know how to simulate.  The only
            safe thing to do would be to set every value we're tracking
-           to 'unknown'.  Instead, we'll be optimistic: we just stop
-           interpreting, and assume that the machine state we've got
-           now is good enough for unwinding the stack.  */
-        break;
+           to 'unknown'.  Instead, we'll be optimistic: we assume that
+	   we *can* interpret every instruction that the compiler uses
+	   to manipulate any of the data we're interested in here --
+	   then we can just ignore anything else.  */
+        ;
 
       /* Record the address after the last instruction that changed
          the FP, SP, or backlink.  Ignore instructions that changed
@@ -1641,195 +1665,32 @@ s390_get_frame_info (CORE_ADDR start_pc,
          restore instructions.  (The back chain is never restored,
          just popped.)  */
       {
-        struct prologue_value *sp = &gpr[S390_SP_REGNUM - S390_R0_REGNUM];
-        struct prologue_value *fp = &gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
+        struct prologue_value *sp = &data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
+        struct prologue_value *fp = &data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
         
         if ((! pv_is_identical (&pre_insn_sp, sp)
              && ! pv_is_register (sp, S390_SP_REGNUM, 0))
             || (! pv_is_identical (&pre_insn_fp, fp)
                 && ! pv_is_register (fp, S390_FRAME_REGNUM, 0))
-            || ! pv_is_identical (&pre_insn_back_chain, &back_chain))
-          after_last_frame_setup_insn = next_pc;
+            || ! pv_is_identical (&pre_insn_back_chain, &data->back_chain))
+          result = next_pc;
       }
     }
 
-  /* Okay, now gpr[], fpr[], spill[], and back_chain reflect the state
-     of the machine as of the first instruction we couldn't interpret
-     (hopefully the first non-prologue instruction).  */
-  {
-    /* The size of the frame, or (CORE_ADDR) -1 if we couldn't figure
-       that out.  */
-    CORE_ADDR frame_size = -1;
-
-    /* The value the SP had upon entry to the function, or
-       (CORE_ADDR) -1 if we can't figure that out.  */
-    CORE_ADDR original_sp = -1;
-
-    /* Are we using S390_FRAME_REGNUM as a frame pointer register?  */
-    int using_frame_pointer = 0;
-
-    /* If S390_FRAME_REGNUM is some constant offset from the SP, then
-       that strongly suggests that we're going to use that as our
-       frame pointer register, not the SP.  */
-    {
-      struct prologue_value *fp = &gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
-
-      if (fp->kind == pv_register
-          && fp->reg == S390_SP_REGNUM)
-        using_frame_pointer = 1;
-    }
-
-    /* If we were given a frame_info structure, we may be able to use
-       the frame's base address to figure out the actual value of the
-       original SP.  */
-    if (fi && get_frame_base (fi))
-      {
-        int frame_base_regno;
-        struct prologue_value *frame_base;
-
-        /* The meaning of the frame base depends on whether the
-           function uses a frame pointer register other than the SP or
-           not (see s390_read_fp):
-           - If the function does use a frame pointer register other
-             than the SP, then the frame base is that register's
-             value.
-           - If the function doesn't use a frame pointer, then the
-             frame base is the SP itself.
-           We're duplicating some of the logic of s390_fp_regnum here,
-           but we don't want to call that, because it would just do
-           exactly the same analysis we've already done above.  */
-        if (using_frame_pointer)
-          frame_base_regno = S390_FRAME_REGNUM;
-        else
-          frame_base_regno = S390_SP_REGNUM;
-
-        frame_base = &gpr[frame_base_regno - S390_R0_REGNUM];
-
-        /* We know the frame base address; if the value of whatever
-           register it came from is a constant offset from the
-           original SP, then we can reconstruct the original SP just
-           by subtracting off that constant.  */
-        if (frame_base->kind == pv_register
-            && frame_base->reg == S390_SP_REGNUM)
-          original_sp = get_frame_base (fi) - frame_base->k;
-      }
-
-    /* If the analysis said that the current SP value is the original
-       value less some constant, then that constant is the frame size.  */
-    {
-      struct prologue_value *sp = &gpr[S390_SP_REGNUM - S390_R0_REGNUM];
-
-      if (sp->kind == pv_register
-          && sp->reg == S390_SP_REGNUM)
-        frame_size = -sp->k;
-    }
-
-    /* If we knew other registers' current values, we could check if
-       the analysis said any of those were related to the original SP
-       value, too.  But for now, we'll just punt.  */
-
-    /* If the caller passed in an 'extra info' structure, fill in the
-       parts we can.  */
-    if (fextra_info)
-      {
-        if (init_extra_info || ! fextra_info->initialised)
-          {
-            s390_memset_extra_info (fextra_info);
-            fextra_info->function_start = start_pc;
-            fextra_info->initialised = 1;
-          }
-
-        if (frame_size != -1)
-          {
-            fextra_info->stack_bought_valid = 1;
-            fextra_info->stack_bought = frame_size;
-          }
-
-        /* Assume everything was okay, and indicate otherwise when we
-           find something amiss.  */
-        fextra_info->good_prologue = 1;
-
-        if (using_frame_pointer)
-          /* Actually, nobody cares about the exact PC, so any
-             non-zero value will do here.  */
-          fextra_info->frame_pointer_saved_pc = 1;
-
-        /* If we weren't able to find the size of the frame, or find
-           the original sp based on actual current register values,
-           then we're not going to be able to unwind this frame.
-
-           (If we're just doing prologue analysis to set a breakpoint,
-           then frame_size might be known, but original_sp unknown; if
-           we're analyzing a real frame which uses alloca, then
-           original_sp might be known (from the frame pointer
-           register), but the frame size might be unknown.)  */
-        if (original_sp == -1 && frame_size == -1)
-          fextra_info->good_prologue = 0;
-        
-        if (fextra_info->good_prologue)
-          fextra_info->skip_prologue_function_start
-            = after_last_frame_setup_insn;
-        else 
-          /* If the prologue was too complex for us to make sense of,
-             then perhaps it's better to just not skip anything at
-             all.  */
-          fextra_info->skip_prologue_function_start = start_pc;
-      }
-
-    /* Indicate where registers were saved on the stack, if:
-       - the caller seems to want to know,
-       - the caller provided an actual SP, and
-       - the analysis gave us enough information to actually figure it
-         out.  */
-    if (fi
-        && deprecated_get_frame_saved_regs (fi)
-        && original_sp != -1)
-      {
-        int slot_num;
-        CORE_ADDR slot_addr;
-        CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
-
-        /* Scan the spill array; if a spill slot says it holds the
-           original value of some register, then record that slot's
-           address as the place that register was saved.
-
-           Just for kicks, note that, even if registers aren't saved
-           in their officially-sanctioned slots, this will still work
-           --- we know what really got put where.  */
-
-        /* First, the slots for r2 -- r15.  */
-        for (slot_num = 0, slot_addr = original_sp + 2 * S390_GPR_SIZE;
-             slot_num < 14;
-             slot_num++, slot_addr += S390_GPR_SIZE)
-          {
-            struct prologue_value *slot = &spill[slot_num];
-
-            if (slot->kind == pv_register
-                && slot->k == 0)
-              saved_regs[slot->reg] = slot_addr;
-          }
-
-        /* Then, the slots for f0, f2, f4, and f6.  They're a
-           different size.  */
-        for (slot_num = 14, slot_addr = original_sp + 16 * S390_GPR_SIZE;
-             slot_num < S390_NUM_SPILL_SLOTS;
-             slot_num++, slot_addr += S390_FPR_SIZE)
-          {
-            struct prologue_value *slot = &spill[slot_num];
-            
-            if (slot->kind == pv_register
-                && slot->k == 0)
-              saved_regs[slot->reg] = slot_addr;
-          }
-
-        /* The stack pointer's element of saved_regs[] is special.  */
-        saved_regs[S390_SP_REGNUM] = original_sp;
-      }
-  }
-
   return result;
 }
 
+/* Advance PC across any function entry prologue instructions to reach 
+   some "real" code.  */
+static CORE_ADDR
+s390_skip_prologue (CORE_ADDR pc)
+{
+  struct s390_prologue_data data;
+  CORE_ADDR skip_pc;
+  skip_pc = s390_analyze_prologue (current_gdbarch, pc, (CORE_ADDR)-1, &data);
+  return skip_pc ? skip_pc : pc;
+}
+
 /* Return true if we are in the functin's epilogue, i.e. after the
    instruction that destroyed the function's stack frame.  */
 static int
@@ -1866,458 +1727,573 @@ s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
     return 1;
 
+  if (word_size == 4
+      && !read_memory_nobpt (pc - 6, insn, 6)
+      && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
+      && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
+    return 1;
+
   if (word_size == 8
       && !read_memory_nobpt (pc - 6, insn, 6)
-      && is_rse (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
+      && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
     return 1;
 
   return 0;
 }
 
+
+/* Normal stack frames.  */
+
+struct s390_unwind_cache {
+
+  CORE_ADDR func;
+  CORE_ADDR frame_base;
+  CORE_ADDR local_base;
+
+  struct trad_frame_saved_reg *saved_regs;
+};
+
 static int
-s390_check_function_end (CORE_ADDR pc)
+s390_prologue_frame_unwind_cache (struct frame_info *next_frame,
+				  struct s390_unwind_cache *info)
 {
-  bfd_byte instr[S390_MAX_INSTR_SIZE];
-  int regidx, instrlen;
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+  struct s390_prologue_data data;
+  struct prologue_value *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
+  struct prologue_value *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
+  int slot_num;
+  CORE_ADDR slot_addr;
+  CORE_ADDR func;
+  CORE_ADDR result;
+  ULONGEST reg;
+  CORE_ADDR prev_sp;
+  int frame_pointer;
+  int size;
+
+  /* Try to find the function start address.  If we can't find it, we don't
+     bother searching for it -- with modern compilers this would be mostly
+     pointless anyway.  Trust that we'll either have valid DWARF-2 CFI data
+     or else a valid backchain ...  */
+  func = frame_func_unwind (next_frame);
+  if (!func)
+    return 0;
 
-  instrlen = s390_readinstruction (instr, pc);
-  if (instrlen < 0)
-    return -1;
-  /* check for BR */
-  if (instrlen != 2 || instr[0] != 07 || (instr[1] >> 4) != 0xf)
+  /* Try to analyze the prologue.  */
+  result = s390_analyze_prologue (gdbarch, func,
+				  frame_pc_unwind (next_frame), &data);
+  if (!result)
     return 0;
-  regidx = instr[1] & 0xf;
-  /* Check for LMG or LG */
-  instrlen =
-    s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 6 : 4));
-  if (instrlen < 0)
-    return -1;
-  if (GDB_TARGET_IS_ESAME)
-    {
 
-      if (instrlen != 6 || instr[0] != 0xeb || instr[5] != 0x4)
-	return 0;
-    }
-  else if (instrlen != 4 || instr[0] != 0x98)
-    {
-      return 0;
-    }
-  if ((instr[2] >> 4) != 0xf)
+  /* If this was successful, we should have found the instruction that
+     sets the stack pointer register to the previous value of the stack 
+     pointer minus the frame size.  */
+  if (sp->kind != pv_register || sp->reg != S390_SP_REGNUM)
     return 0;
-  if (regidx == 14)
-    return 1;
-  instrlen = s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 12 : 8));
-  if (instrlen < 0)
-    return -1;
-  if (GDB_TARGET_IS_ESAME)
-    {
-      /* Check for LG */
-      if (instrlen != 6 || instr[0] != 0xe3 || instr[5] != 0x4)
-	return 0;
-    }
-  else
+
+  /* A frame size of zero at this point can mean either a real 
+     frameless function, or else a failure to find the prologue.
+     Perform some sanity checks to verify we really have a 
+     frameless function.  */
+  if (sp->k == 0)
     {
-      /* Check for L */
-      if (instrlen != 4 || instr[0] != 0x58)
+      /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame 
+	 size zero.  This is only possible if the next frame is a sentinel 
+	 frame, a dummy frame, or a signal trampoline frame.  */
+      if (get_frame_type (next_frame) == NORMAL_FRAME
+	  /* For some reason, sentinel frames are NORMAL_FRAMEs
+	     -- but they have negative frame level.  */
+	  && frame_relative_level (next_frame) >= 0)
 	return 0;
-    }
-  if (instr[2] >> 4 != 0xf)
-    return 0;
-  if (instr[1] >> 4 != regidx)
-    return 0;
-  return 1;
-}
-
-static CORE_ADDR
-s390_sniff_pc_function_start (CORE_ADDR pc, struct frame_info *fi)
-{
-  CORE_ADDR function_start, test_function_start;
-  int loop_cnt, err, function_end;
-  struct frame_extra_info fextra_info;
-  function_start = get_pc_function_start (pc);
 
-  if (function_start == 0)
-    {
-      test_function_start = pc;
-      if (test_function_start & 1)
-	return 0;		/* This has to be bogus */
-      loop_cnt = 0;
-      do
+      /* If we really have a frameless function, %r14 must be valid
+	 -- in particular, it must point to a different function.  */
+      reg = frame_unwind_register_unsigned (next_frame, S390_RETADDR_REGNUM);
+      reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
+      if (get_pc_function_start (reg) == func)
 	{
+	  /* However, there is one case where it *is* valid for %r14
+	     to point to the same function -- if this is a recursive
+	     call, and we have stopped in the prologue *before* the
+	     stack frame was allocated.
+
+	     Recognize this case by looking ahead a bit ...  */
 
-	  err =
-	    s390_get_frame_info (test_function_start, &fextra_info, fi, 1);
-	  loop_cnt++;
-	  test_function_start -= 2;
-	  function_end = s390_check_function_end (test_function_start);
+	  struct s390_prologue_data data2;
+	  struct prologue_value *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
+
+	  if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
+	        && sp->kind == pv_register
+	        && sp->reg == S390_SP_REGNUM
+	        && sp->k != 0))
+	    return 0;
 	}
-      while (!(function_end == 1 || err || loop_cnt >= 4096 ||
-	       (fextra_info.good_prologue)));
-      if (fextra_info.good_prologue)
-	function_start = fextra_info.function_start;
-      else if (function_end == 1)
-	function_start = test_function_start;
     }
-  return function_start;
-}
 
 
-static int
-s390_frameless_function_invocation (struct frame_info *fi)
-{
-  struct frame_extra_info fextra_info, *fextra_info_ptr;
-  int frameless = 0;
+  /* OK, we've found valid prologue data.  */
+  size = -sp->k;
 
-  if (get_next_frame (fi) == NULL)		/* no may be frameless */
+  /* If the frame pointer originally also holds the same value
+     as the stack pointer, we're probably using it.  If it holds
+     some other value -- even a constant offset -- it is most
+     likely used as temp register.  */
+  if (pv_is_identical (sp, fp))
+    frame_pointer = S390_FRAME_REGNUM;
+  else
+    frame_pointer = S390_SP_REGNUM;
+
+  /* If we've detected a function with stack frame, we'll still have to 
+     treat it as frameless if we're currently within the function epilog 
+     code at a point where the frame pointer has already been restored.  
+     This can only happen in an innermost frame.  */
+  if (size > 0
+      && (get_frame_type (next_frame) != NORMAL_FRAME
+	  || frame_relative_level (next_frame) < 0))
     {
-      if (get_frame_extra_info (fi))
-	fextra_info_ptr = get_frame_extra_info (fi);
-      else
+      /* See the comment in s390_in_function_epilogue_p on why this is
+	 not completely reliable ...  */
+      if (s390_in_function_epilogue_p (gdbarch, frame_pc_unwind (next_frame)))
 	{
-	  fextra_info_ptr = &fextra_info;
-	  s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
-			       fextra_info_ptr, fi, 1);
+	  memset (&data, 0, sizeof (data));
+	  size = 0;
+	  frame_pointer = S390_SP_REGNUM;
 	}
-      frameless = (fextra_info_ptr->stack_bought_valid
-                   && fextra_info_ptr->stack_bought == 0);
     }
-  return frameless;
 
-}
+  /* Once we know the frame register and the frame size, we can unwind
+     the current value of the frame register from the next frame, and
+     add back the frame size to arrive that the previous frame's 
+     stack pointer value.  */
+  prev_sp = frame_unwind_register_unsigned (next_frame, frame_pointer) + size;
 
+  /* Scan the spill array; if a spill slot says it holds the
+     original value of some register, then record that slot's
+     address as the place that register was saved.  */
 
-static int
-s390_is_sigreturn (CORE_ADDR pc, struct frame_info *sighandler_fi,
-		   CORE_ADDR *sregs, CORE_ADDR *sigcaller_pc)
-{
-  bfd_byte instr[S390_MAX_INSTR_SIZE];
-  int instrlen;
-  CORE_ADDR scontext;
-  int retval = 0;
-  CORE_ADDR orig_sp;
-  CORE_ADDR temp_sregs;
-
-  scontext = temp_sregs = 0;
-
-  instrlen = s390_readinstruction (instr, pc);
-  if (sigcaller_pc)
-    *sigcaller_pc = 0;
-  if (((instrlen == S390_SYSCALL_SIZE) &&
-       (instr[0] == S390_SYSCALL_OPCODE)) &&
-      ((instr[1] == s390_NR_sigreturn) || (instr[1] == s390_NR_rt_sigreturn)))
+  /* Slots for %r2 .. %r15.  */
+  for (slot_num = 0, slot_addr = prev_sp + 2 * data.gpr_size;
+       slot_num < 14;
+       slot_num++, slot_addr += data.gpr_size)
     {
-      if (sighandler_fi)
-	{
-	  if (s390_frameless_function_invocation (sighandler_fi))
-	    orig_sp = get_frame_base (sighandler_fi);
-	  else
-	    orig_sp = ADDR_BITS_REMOVE ((CORE_ADDR)
-					read_memory_integer (get_frame_base (sighandler_fi),
-							     S390_GPR_SIZE));
-	  if (orig_sp && sigcaller_pc)
-	    {
-	      scontext = orig_sp + S390_SIGNAL_FRAMESIZE;
-	      if (pc == scontext && instr[1] == s390_NR_rt_sigreturn)
-		{
-		  /* We got a new style rt_signal */
-		  /* get address of read ucontext->uc_mcontext */
-		  temp_sregs = orig_sp + (GDB_TARGET_IS_ESAME ?
-					  S390X_UC_MCONTEXT_OFFSET :
-					  S390_UC_MCONTEXT_OFFSET);
-		}
-	      else
-		{
-		  /* read sigcontext->sregs */
-		  temp_sregs = ADDR_BITS_REMOVE ((CORE_ADDR)
-						 read_memory_integer (scontext
-								      +
-								      (GDB_TARGET_IS_ESAME
-								       ?
-								       S390X_SIGCONTEXT_SREGS_OFFSET
-								       :
-								       S390_SIGCONTEXT_SREGS_OFFSET),
-								      S390_GPR_SIZE));
-
-		}
-	      /* read sigregs->psw.addr */
-	      *sigcaller_pc =
-		ADDR_BITS_REMOVE ((CORE_ADDR)
-				  read_memory_integer (temp_sregs +
-						       DEPRECATED_REGISTER_BYTE (S390_PSWA_REGNUM),
-						       S390_GPR_SIZE));
-	    }
-	}
-      retval = 1;
+      struct prologue_value *slot = &data.spill[slot_num];
+
+      if (slot->kind == pv_register
+          && slot->k == 0)
+        info->saved_regs[slot->reg].addr = slot_addr;
     }
-  if (sregs)
-    *sregs = temp_sregs;
-  return retval;
-}
 
-/*
-  We need to do something better here but this will keep us out of trouble
-  for the moment.
-  For some reason the blockframe.c calls us with fi->next->fromleaf
-  so this seems of little use to us. */
-static CORE_ADDR
-s390_init_frame_pc_first (int next_fromleaf, struct frame_info *fi)
-{
-  CORE_ADDR sigcaller_pc;
-  CORE_ADDR pc = 0;
-  if (next_fromleaf)
+  /* Slots for %f0 .. %f6.  */
+  for (slot_num = 14, slot_addr = prev_sp + 16 * data.gpr_size;
+       slot_num < S390_NUM_SPILL_SLOTS;
+       slot_num++, slot_addr += data.fpr_size)
     {
-      pc = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
-      /* fix signal handlers */
+      struct prologue_value *slot = &data.spill[slot_num];
+
+      if (slot->kind == pv_register
+          && slot->k == 0)
+        info->saved_regs[slot->reg].addr = slot_addr;
+    }
+
+  /* Function return will set PC to %r14.  */
+  info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
+
+  /* In frameless functions, we unwind simply by moving the return
+     address to the PC.  However, if we actually stored to the
+     save area, use that -- we might only think the function frameless
+     because we're in the middle of the prologue ...  */
+  if (size == 0
+      && !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
+    {
+      info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
     }
-  else if (get_next_frame (fi) && get_frame_pc (get_next_frame (fi)))
-    pc = s390_frame_saved_pc_nofix (get_next_frame (fi));
-  if (pc && get_next_frame (fi) && get_frame_base (get_next_frame (fi))
-      && s390_is_sigreturn (pc, get_next_frame (fi), NULL, &sigcaller_pc))
+
+  /* Another sanity check: unless this is a frameless function,
+     we should have found spill slots for SP and PC.
+     If not, we cannot unwind further -- this happens e.g. in
+     libc's thread_start routine.  */
+  if (size > 0)
     {
-      pc = sigcaller_pc;
+      if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
+	  || !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
+	prev_sp = -1;
     }
-  return pc;
+
+  /* We use the current value of the frame register as local_base,
+     and the top of the register save area as frame_base.  */
+  if (prev_sp != -1)
+    {
+      info->frame_base = prev_sp + 16*word_size + 32;
+      info->local_base = prev_sp - size;
+    }
+
+  info->func = func;
+  return 1;
 }
 
 static void
-s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
+s390_backchain_frame_unwind_cache (struct frame_info *next_frame,
+				   struct s390_unwind_cache *info)
 {
-  frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
-  if (get_frame_pc (fi))
-    s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
-			 get_frame_extra_info (fi), fi, 1);
-  else
-    s390_memset_extra_info (get_frame_extra_info (fi));
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+  CORE_ADDR backchain;
+  ULONGEST reg;
+  LONGEST sp;
+
+  /* Get the backchain.  */
+  reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
+  backchain = read_memory_unsigned_integer (reg, word_size);
+
+  /* A zero backchain terminates the frame chain.  As additional
+     sanity check, let's verify that the spill slot for SP in the
+     save area pointed to by the backchain in fact links back to
+     the save area.  */
+  if (backchain != 0
+      && safe_read_memory_integer (backchain + 15*word_size, word_size, &sp)
+      && (CORE_ADDR)sp == backchain)
+    {
+      /* We don't know which registers were saved, but it will have
+         to be at least %r14 and %r15.  This will allow us to continue
+         unwinding, but other prev-frame registers may be incorrect ...  */
+      info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
+      info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
+
+      /* Function return will set PC to %r14.  */
+      info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
+
+      /* We use the current value of the frame register as local_base,
+         and the top of the register save area as frame_base.  */
+      info->frame_base = backchain + 16*word_size + 32;
+      info->local_base = reg;
+    }
+
+  info->func = frame_pc_unwind (next_frame);
 }
 
-/* If saved registers of frame FI are not known yet, read and cache them.
-   &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
-   in which case the framedata are read.  */
+static struct s390_unwind_cache *
+s390_frame_unwind_cache (struct frame_info *next_frame,
+			 void **this_prologue_cache)
+{
+  struct s390_unwind_cache *info;
+  if (*this_prologue_cache)
+    return *this_prologue_cache;
+
+  info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
+  *this_prologue_cache = info;
+  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+  info->func = -1;
+  info->frame_base = -1;
+  info->local_base = -1;
+
+  /* Try to use prologue analysis to fill the unwind cache.
+     If this fails, fall back to reading the stack backchain.  */
+  if (!s390_prologue_frame_unwind_cache (next_frame, info))
+    s390_backchain_frame_unwind_cache (next_frame, info);
+
+  return info;
+}
 
 static void
-s390_frame_init_saved_regs (struct frame_info *fi)
+s390_frame_this_id (struct frame_info *next_frame,
+		    void **this_prologue_cache,
+		    struct frame_id *this_id)
 {
+  struct s390_unwind_cache *info
+    = s390_frame_unwind_cache (next_frame, this_prologue_cache);
 
-  int quick;
+  if (info->frame_base == -1)
+    return;
 
-  if (deprecated_get_frame_saved_regs (fi) == NULL)
-    {
-      /* zalloc memsets the saved regs */
-      frame_saved_regs_zalloc (fi);
-      if (get_frame_pc (fi))
-	{
-	  quick = (get_frame_extra_info (fi)
-		   && get_frame_extra_info (fi)->initialised
-		   && get_frame_extra_info (fi)->good_prologue);
-	  s390_get_frame_info (quick
-			       ? get_frame_extra_info (fi)->function_start
-			       : s390_sniff_pc_function_start (get_frame_pc (fi), fi),
-			       get_frame_extra_info (fi), fi, !quick);
-	}
-    }
+  *this_id = frame_id_build (info->frame_base, info->func);
 }
 
+static void
+s390_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, void *bufferp)
+{
+  struct s390_unwind_cache *info
+    = s390_frame_unwind_cache (next_frame, this_prologue_cache);
+  trad_frame_prev_register (next_frame, info->saved_regs, regnum,
+                            optimizedp, lvalp, addrp, realnump, bufferp);
+}
+
+static const struct frame_unwind s390_frame_unwind = {
+  NORMAL_FRAME,
+  s390_frame_this_id,
+  s390_frame_prev_register
+};
+
+static const struct frame_unwind *
+s390_frame_sniffer (struct frame_info *next_frame)
+{
+  return &s390_frame_unwind;
+}
 
 
-static CORE_ADDR
-s390_frame_saved_pc_nofix (struct frame_info *fi)
+/* PLT stub stack frames.  */
+
+struct s390_pltstub_unwind_cache {
+
+  CORE_ADDR frame_base;
+  struct trad_frame_saved_reg *saved_regs;
+};
+
+static struct s390_pltstub_unwind_cache *
+s390_pltstub_frame_unwind_cache (struct frame_info *next_frame,
+				 void **this_prologue_cache)
 {
-  if (get_frame_extra_info (fi) && get_frame_extra_info (fi)->saved_pc_valid)
-    return get_frame_extra_info (fi)->saved_pc;
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+  struct s390_pltstub_unwind_cache *info;
+  ULONGEST reg;
 
-  if (deprecated_generic_find_dummy_frame (get_frame_pc (fi),
-					   get_frame_base (fi)))
-    return deprecated_read_register_dummy (get_frame_pc (fi),
-					   get_frame_base (fi), S390_PC_REGNUM);
+  if (*this_prologue_cache)
+    return *this_prologue_cache;
 
-  s390_frame_init_saved_regs (fi);
-  if (get_frame_extra_info (fi))
-    {
-      get_frame_extra_info (fi)->saved_pc_valid = 1;
-      if (get_frame_extra_info (fi)->good_prologue
-          && deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
-        get_frame_extra_info (fi)->saved_pc
-          = ADDR_BITS_REMOVE (read_memory_integer
-                              (deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
-                               S390_GPR_SIZE));
-      else
-        get_frame_extra_info (fi)->saved_pc
-          = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
-      return get_frame_extra_info (fi)->saved_pc;
-    }
-  return 0;
+  info = FRAME_OBSTACK_ZALLOC (struct s390_pltstub_unwind_cache);
+  *this_prologue_cache = info;
+  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+  /* The return address is in register %r14.  */
+  info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
+
+  /* Retrieve stack pointer and determine our frame base.  */
+  reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
+  info->frame_base = reg + 16*word_size + 32;
+
+  return info;
 }
 
-static CORE_ADDR
-s390_frame_saved_pc (struct frame_info *fi)
+static void
+s390_pltstub_frame_this_id (struct frame_info *next_frame,
+			    void **this_prologue_cache,
+			    struct frame_id *this_id)
 {
-  CORE_ADDR saved_pc = 0, sig_pc;
+  struct s390_pltstub_unwind_cache *info
+    = s390_pltstub_frame_unwind_cache (next_frame, this_prologue_cache);
+  *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
+}
 
-  if (get_frame_extra_info (fi)
-      && get_frame_extra_info (fi)->sig_fixed_saved_pc_valid)
-    return get_frame_extra_info (fi)->sig_fixed_saved_pc;
-  saved_pc = s390_frame_saved_pc_nofix (fi);
+static void
+s390_pltstub_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, void *bufferp)
+{
+  struct s390_pltstub_unwind_cache *info
+    = s390_pltstub_frame_unwind_cache (next_frame, this_prologue_cache);
+  trad_frame_prev_register (next_frame, info->saved_regs, regnum,
+                            optimizedp, lvalp, addrp, realnump, bufferp);
+}
+
+static const struct frame_unwind s390_pltstub_frame_unwind = {
+  NORMAL_FRAME,
+  s390_pltstub_frame_this_id,
+  s390_pltstub_frame_prev_register
+};
 
-  if (get_frame_extra_info (fi))
-    {
-      get_frame_extra_info (fi)->sig_fixed_saved_pc_valid = 1;
-      if (saved_pc)
-	{
-	  if (s390_is_sigreturn (saved_pc, fi, NULL, &sig_pc))
-	    saved_pc = sig_pc;
-	}
-      get_frame_extra_info (fi)->sig_fixed_saved_pc = saved_pc;
-    }
-  return saved_pc;
-}
+static const struct frame_unwind *
+s390_pltstub_frame_sniffer (struct frame_info *next_frame)
+{
+  if (!in_plt_section (frame_pc_unwind (next_frame), NULL))
+    return NULL;
 
+  return &s390_pltstub_frame_unwind;
+}
 
 
+/* Signal trampoline stack frames.  */
 
-/* We want backtraces out of signal handlers so we don't set
-   (get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
+struct s390_sigtramp_unwind_cache {
+  CORE_ADDR frame_base;
+  struct trad_frame_saved_reg *saved_regs;
+};
 
-static CORE_ADDR
-s390_frame_chain (struct frame_info *thisframe)
+static struct s390_sigtramp_unwind_cache *
+s390_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
+				  void **this_prologue_cache)
 {
-  CORE_ADDR prev_fp = 0;
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+  struct s390_sigtramp_unwind_cache *info;
+  ULONGEST this_sp, prev_sp;
+  CORE_ADDR next_ra, next_cfa, sigreg_ptr;
+  int i;
+
+  if (*this_prologue_cache)
+    return *this_prologue_cache;
 
-  if (deprecated_generic_find_dummy_frame (get_frame_pc (thisframe),
-					   get_frame_base (thisframe)))
-    return deprecated_read_register_dummy (get_frame_pc (thisframe),
-					   get_frame_base (thisframe),
-					   S390_SP_REGNUM);
+  info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
+  *this_prologue_cache = info;
+  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+  this_sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
+  next_ra = frame_pc_unwind (next_frame);
+  next_cfa = this_sp + 16*word_size + 32;
+
+  /* New-style RT frame:
+	retcode + alignment (8 bytes)
+	siginfo (128 bytes)
+	ucontext (contains sigregs at offset 5 words)  */
+  if (next_ra == next_cfa)
+    {
+      sigreg_ptr = next_cfa + 8 + 128 + 5*word_size;
+    }
+
+  /* Old-style RT frame and all non-RT frames:
+	old signal mask (8 bytes)
+	pointer to sigregs  */
   else
     {
-      int sigreturn = 0;
-      CORE_ADDR sregs = 0;
-      struct frame_extra_info prev_fextra_info;
+      sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8, word_size);
+    }
 
-      memset (&prev_fextra_info, 0, sizeof (prev_fextra_info));
-      if (get_frame_pc (thisframe))
-	{
-	  CORE_ADDR saved_pc, sig_pc;
+  /* The sigregs structure looks like this:
+            long   psw_mask;
+            long   psw_addr;
+            long   gprs[16];
+            int    acrs[16];
+            int    fpc;
+            int    __pad;
+            double fprs[16];  */
 
-	  saved_pc = s390_frame_saved_pc_nofix (thisframe);
-	  if (saved_pc)
-	    {
-	      if ((sigreturn =
-		   s390_is_sigreturn (saved_pc, thisframe, &sregs, &sig_pc)))
-		saved_pc = sig_pc;
-	      s390_get_frame_info (s390_sniff_pc_function_start
-				   (saved_pc, NULL), &prev_fextra_info, NULL,
-				   1);
-	    }
-	}
-      if (sigreturn)
-	{
-	  /* read sigregs,regs.gprs[11 or 15] */
-	  prev_fp = read_memory_integer (sregs +
-					 DEPRECATED_REGISTER_BYTE (S390_R0_REGNUM +
-							(prev_fextra_info.
-							 frame_pointer_saved_pc
-							 ? 11 : 15)),
-					 S390_GPR_SIZE);
-	  get_frame_extra_info (thisframe)->sigcontext = sregs;
-	}
-      else
-	{
-	  if (deprecated_get_frame_saved_regs (thisframe))
-	    {
-	      int regno;
-
-              if (prev_fextra_info.frame_pointer_saved_pc
-                  && deprecated_get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
-                regno = S390_FRAME_REGNUM;
-              else
-                regno = S390_SP_REGNUM;
-
-	      if (deprecated_get_frame_saved_regs (thisframe)[regno])
-                {
-                  /* The SP's entry of `saved_regs' is special.  */
-                  if (regno == S390_SP_REGNUM)
-                    prev_fp = deprecated_get_frame_saved_regs (thisframe)[regno];
-                  else
-                    prev_fp =
-                      read_memory_integer (deprecated_get_frame_saved_regs (thisframe)[regno],
-                                           S390_GPR_SIZE);
-                }
-	    }
-	}
+  /* Let's ignore the PSW mask, it will not be restored anyway.  */
+  sigreg_ptr += word_size;
+
+  /* Next comes the PSW address.  */
+  info->saved_regs[S390_PC_REGNUM].addr = sigreg_ptr;
+  sigreg_ptr += word_size;
+
+  /* Then the GPRs.  */
+  for (i = 0; i < 16; i++)
+    {
+      info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
+      sigreg_ptr += word_size;
+    }
+
+  /* Then the ACRs.  */
+  for (i = 0; i < 16; i++)
+    {
+      info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
+      sigreg_ptr += 4;
     }
-  return ADDR_BITS_REMOVE (prev_fp);
-}
 
-/*
-  Whether struct frame_extra_info is actually needed I'll have to figure
-  out as our frames are similar to rs6000 there is a possibility
-  i386 dosen't need it. */
+  /* The floating-point control word.  */
+  info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
+  sigreg_ptr += 8;
 
-/* Not the most efficent code in the world */
-static int
-s390_fp_regnum (void)
-{
-  int regno = S390_SP_REGNUM;
-  struct frame_extra_info fextra_info;
+  /* And finally the FPRs.  */
+  for (i = 0; i < 16; i++)
+    {
+      info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
+      sigreg_ptr += 8;
+    }
+
+  /* Restore the previous frame's SP.  */
+  prev_sp = read_memory_unsigned_integer (
+			info->saved_regs[S390_SP_REGNUM].addr,
+			word_size);
 
-  CORE_ADDR pc = ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM));
+  /* Determine our frame base.  */
+  info->frame_base = prev_sp + 16*word_size + 32;
 
-  s390_get_frame_info (s390_sniff_pc_function_start (pc, NULL), &fextra_info,
-		       NULL, 1);
-  if (fextra_info.frame_pointer_saved_pc)
-    regno = S390_FRAME_REGNUM;
-  return regno;
+  return info;
 }
 
-static CORE_ADDR
-s390_read_fp (void)
+static void
+s390_sigtramp_frame_this_id (struct frame_info *next_frame,
+			     void **this_prologue_cache,
+			     struct frame_id *this_id)
 {
-  return read_register (s390_fp_regnum ());
+  struct s390_sigtramp_unwind_cache *info
+    = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+  *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
 }
 
-
 static void
-s390_pop_frame_regular (struct frame_info *frame)
+s390_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, void *bufferp)
+{
+  struct s390_sigtramp_unwind_cache *info
+    = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+  trad_frame_prev_register (next_frame, info->saved_regs, regnum,
+                            optimizedp, lvalp, addrp, realnump, bufferp);
+}
+
+static const struct frame_unwind s390_sigtramp_frame_unwind = {
+  SIGTRAMP_FRAME,
+  s390_sigtramp_frame_this_id,
+  s390_sigtramp_frame_prev_register
+};
+
+static const struct frame_unwind *
+s390_sigtramp_frame_sniffer (struct frame_info *next_frame)
 {
-  int regnum;
+  CORE_ADDR pc = frame_pc_unwind (next_frame);
+  bfd_byte sigreturn[2];
 
-  write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
+  if (read_memory_nobpt (pc, sigreturn, 2))
+    return NULL;
 
-  /* Restore any saved registers.  */
-  if (deprecated_get_frame_saved_regs (frame))
-    {
-      for (regnum = 0; regnum < NUM_REGS; regnum++)
-        if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
-          {
-            ULONGEST value;
-            
-            value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
-                                                  DEPRECATED_REGISTER_RAW_SIZE (regnum));
-            write_register (regnum, value);
-          }
-
-      /* Actually cut back the stack.  Remember that the SP's element of
-         saved_regs is the old SP itself, not the address at which it is
-         saved.  */
-      write_register (S390_SP_REGNUM, deprecated_get_frame_saved_regs (frame)[S390_SP_REGNUM]);
-    }
+  if (sigreturn[0] != 0x0a /* svc */)
+    return NULL;
 
-  /* Throw away any cached frame information.  */
-  flush_cached_frames ();
+  if (sigreturn[1] != 119 /* sigreturn */
+      && sigreturn[1] != 173 /* rt_sigreturn */)
+    return NULL;
+  
+  return &s390_sigtramp_frame_unwind;
 }
 
 
-/* Destroy the innermost (Top-Of-Stack) stack frame, restoring the 
-   machine state that was in effect before the frame was created. 
-   Used in the contexts of the "return" command, and of 
-   target function calls from the debugger.  */
-static void
-s390_pop_frame (void)
+/* Frame base handling.  */
+
+static CORE_ADDR
+s390_frame_base_address (struct frame_info *next_frame, void **this_cache)
 {
-  /* This function checks for and handles generic dummy frames, and
-     calls back to our function for ordinary frames.  */
-  generic_pop_current_frame (s390_pop_frame_regular);
+  struct s390_unwind_cache *info
+    = s390_frame_unwind_cache (next_frame, this_cache);
+  return info->frame_base;
+}
+
+static CORE_ADDR
+s390_local_base_address (struct frame_info *next_frame, void **this_cache)
+{
+  struct s390_unwind_cache *info
+    = s390_frame_unwind_cache (next_frame, this_cache);
+  return info->local_base;
+}
+
+static const struct frame_base s390_frame_base = {
+  &s390_frame_unwind,
+  s390_frame_base_address,
+  s390_local_base_address,
+  s390_local_base_address
+};
+
+static CORE_ADDR
+s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+  ULONGEST pc;
+  pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);
+  return gdbarch_addr_bits_remove (gdbarch, pc);
+}
+
+static CORE_ADDR
+s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+  ULONGEST sp;
+  sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
+  return gdbarch_addr_bits_remove (gdbarch, sp);
 }
 
 
@@ -2686,8 +2662,10 @@ s390_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
   /* Store updated stack pointer.  */
   regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
 
-  /* Return stack pointer.  */ 
-  return sp;
+  /* We need to return the 'stack part' of the frame ID,
+     which is actually the top of the register save area
+     allocated on the original stack.  */
+  return orig_sp + 16*word_size + 32;
 }
 
 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
@@ -2697,9 +2675,12 @@ s390_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
 static struct frame_id
 s390_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
-  ULONGEST sp;
-  frame_unwind_unsigned_register (next_frame, S390_SP_REGNUM, &sp);
-  return frame_id_build (sp, frame_pc_unwind (next_frame));
+  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
+  CORE_ADDR this_sp = s390_unwind_sp (gdbarch, next_frame);
+  CORE_ADDR prev_sp = read_memory_unsigned_integer (this_sp, word_size);
+
+  return frame_id_build (prev_sp + 16*word_size + 32,
+                         frame_pc_unwind (next_frame));
 }
 
 static CORE_ADDR
@@ -2815,6 +2796,8 @@ s390_return_value (struct gdbarch *gdbarch, struct type *type,
 }
 
 
+/* Breakpoints.  */
+
 static const unsigned char *
 s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 {
@@ -2824,31 +2807,13 @@ s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
   return breakpoint;
 }
 
-/* Advance PC across any function entry prologue instructions to reach some
-   "real" code.  */
-static CORE_ADDR
-s390_skip_prologue (CORE_ADDR pc)
-{
-  struct frame_extra_info fextra_info;
 
-  s390_get_frame_info (pc, &fextra_info, NULL, 1);
-  return fextra_info.skip_prologue_function_start;
-}
-
-/* Immediately after a function call, return the saved pc.
-   Can't go through the frames for this because on some machines
-   the new frame is not set up until the new function executes
-   some instructions.  */
-static CORE_ADDR
-s390_saved_pc_after_call (struct frame_info *frame)
-{
-  return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
-}
+/* Address handling.  */
 
 static CORE_ADDR
 s390_addr_bits_remove (CORE_ADDR addr)
 {
-  return (addr) & 0x7fffffff;
+  return addr & 0x7fffffff;
 }
 
 static int
@@ -2882,6 +2847,9 @@ s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name
     return 0;
 }
 
+
+/* Set up gdbarch struct.  */
+
 static struct gdbarch *
 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 {
@@ -2901,41 +2869,21 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep = XCALLOC (1, struct gdbarch_tdep);
   gdbarch = gdbarch_alloc (&info, tdep);
 
-  /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
-     ready to unwind the PC first (see frame.c:get_prev_frame()).  */
-  set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
-
   set_gdbarch_believe_pcc_promotion (gdbarch, 0);
   set_gdbarch_char_signed (gdbarch, 0);
 
-  set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
-  set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, s390_frame_init_saved_regs);
   /* Amount PC must be decremented by after a breakpoint.  This is
      often the number of bytes returned by BREAKPOINT_FROM_PC but not
      always.  */
   set_gdbarch_decr_pc_after_break (gdbarch, 2);
-  set_gdbarch_deprecated_pop_frame (gdbarch, s390_pop_frame);
   /* Stack grows downward.  */
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
   set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
   set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
-  set_gdbarch_deprecated_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
-  set_gdbarch_deprecated_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
-  set_gdbarch_deprecated_target_read_fp (gdbarch, s390_read_fp);
   set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
-  /* This function that tells us whether the function invocation represented
-     by FI does not have a frame on the stack associated with it.  If it
-     does not, FRAMELESS is set to 1, else 0.  */
-  set_gdbarch_deprecated_frameless_function_invocation (gdbarch, s390_frameless_function_invocation);
-  /* Return saved PC from a frame */
-  set_gdbarch_deprecated_frame_saved_pc (gdbarch, s390_frame_saved_pc);
-  /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and
-     produces the frame's chain-pointer. */
-  set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
-  set_gdbarch_deprecated_saved_pc_after_call (gdbarch, s390_saved_pc_after_call);
+
   set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
   set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
-  set_gdbarch_deprecated_fp_regnum (gdbarch, S390_SP_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
   set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
   set_gdbarch_num_pseudo_regs (gdbarch, S390_NUM_PSEUDO_REGS);
@@ -2957,6 +2905,15 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frame_align (gdbarch, s390_frame_align);
   set_gdbarch_return_value (gdbarch, s390_return_value);
 
+  /* Frame handling.  */
+  set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
+  frame_unwind_append_sniffer (gdbarch, s390_pltstub_frame_sniffer);
+  frame_unwind_append_sniffer (gdbarch, s390_sigtramp_frame_sniffer);
+  frame_unwind_append_sniffer (gdbarch, s390_frame_sniffer);
+  frame_base_set_default (gdbarch, &s390_frame_base);
+  set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
+  set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
+
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_s390_31: