This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[PATCH] S/390 port modernization 4/4
- From: Ulrich Weigand <weigand at i1 dot informatik dot uni-erlangen dot de>
- To: gdb-patches at sources dot redhat dot com
- Cc: uweigand at de dot ibm dot com
- Date: Thu, 4 Dec 2003 21:08:20 +0100 (CET)
- Subject: [PATCH] S/390 port modernization 4/4
Hello,
this is patch 4/4 to update the s390 backend.
The focus of this patch is frame handling; it completely removes
all old-style frame routines and switches the backend to use the
new frame handling using frame_unwind and frame_base.
This is still using prologue analysis; in fact the analyser is
made somewhat more generic: it now understands the new long
displacement instructions introduced with z990, and it is also
more flexible in that it can handle unknown instructions
intermixed with the prologue due to instruction scheduling.
Also, literal pool constants are now accepted in 64-bit mode
as well (not just 31-bit mode).
This patch removes the last (to my knowledge) use of deprecated
features in the s390 backend.
Tested on s390-ibm-linux and s390x-ibm-linux with no new regressions.
Fixes (about) 23 unexpected and 4 known failures on s390;
fixes (about) 26 unexpected and 1 known failures on s390x.
Bye,
Ulrich
ChangeLog:
* 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.
diff -c -p -r gdb-head/gdb/Makefile.in gdb-head-new/gdb/Makefile.in
*** gdb-head/gdb/Makefile.in Wed Dec 3 04:18:03 2003
--- gdb-head-new/gdb/Makefile.in Wed Dec 3 04:18:10 2003
*************** s390-nat.o: s390-nat.c $(defs_h) $(tm_h)
*** 2253,2258 ****
--- 2253,2259 ----
s390-tdep.o: s390-tdep.c $(defs_h) $(arch_utils_h) $(frame_h) $(inferior_h) \
$(symtab_h) $(target_h) $(gdbcore_h) $(gdbcmd_h) $(symfile_h) \
$(objfiles_h) $(tm_h) $(__bfd_bfd_h) $(floatformat_h) $(regcache_h) \
+ $(trad_frame_h) $(frame_base_h) $(frame_unwind_h) \
$(reggroups_h) $(regset_h) $(value_h) $(gdb_assert_h) $(dis_asm_h)
scm-exp.o: scm-exp.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \
$(parser_defs_h) $(language_h) $(value_h) $(c_lang_h) $(scm_lang_h) \
diff -c -p -r gdb-head/gdb/s390-tdep.c gdb-head-new/gdb/s390-tdep.c
*** gdb-head/gdb/s390-tdep.c Wed Dec 3 04:18:03 2003
--- gdb-head-new/gdb/s390-tdep.c Wed Dec 3 04:18:10 2003
***************
*** 36,41 ****
--- 36,44 ----
#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"
*************** s390_regset_from_core_section (struct gd
*** 551,622 ****
}
- #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
--- 554,559 ----
*************** pv_is_array_ref (struct prologue_value *
*** 1008,1039 ****
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,
op_lr = 0x18,
! op_nr = 0x14,
! op_ngr = 0xb980,
! op_s = 0x5b,
op_st = 0x50,
! op_std = 0x60,
op1_stg = 0xe3, op2_stg = 0x24,
op_stm = 0x90,
op1_stmg = 0xeb, op2_stmg = 0x24,
! op_lm = 0x98,
! op1_lmg = 0xeb, op2_lmg = 0x04,
! op_svc = 0x0a,
};
/* 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.
--- 945,1016 ----
op1_* and op2_* enums. */
enum
{
! op1_lhi = 0xa7, op2_lhi = 0x08,
! op1_lghi = 0xa7, op2_lghi = 0x09,
op_lr = 0x18,
! 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,
! 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,
! 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.
*************** is_rs (bfd_byte *insn, int op,
*** 1130,1146 ****
static int
! is_rse (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];
return 1;
}
else
--- 1107,1124 ----
static int
! 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
&& insn[5] == op2)
{
*r1 = (insn[1] >> 4) & 0xf;
*r3 = insn[1] & 0xf;
*b2 = (insn[2] >> 4) & 0xf;
! /* The 'long displacement' is a 20-bit signed integer. */
! *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
! ^ 0x80000) - 0x80000;
return 1;
}
else
*************** is_rx (bfd_byte *insn, int op,
*** 1166,1182 ****
static int
! is_rxe (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];
return 1;
}
else
--- 1144,1161 ----
static int
! 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
&& insn[5] == op2)
{
*r1 = (insn[1] >> 4) & 0xf;
*x2 = insn[1] & 0xf;
*b2 = (insn[2] >> 4) & 0xf;
! /* The 'long displacement' is a 20-bit signed integer. */
! *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
! ^ 0x80000) - 0x80000;
return 1;
}
else
*************** is_rxe (bfd_byte *insn, int op1, int op2
*** 1188,1194 ****
L R1, D2(X2, B2)
! Here, X2 and B2 are registers, and D2 is an unsigned 12-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.
--- 1167,1173 ----
L R1, D2(X2, B2)
! 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.
*************** is_rxe (bfd_byte *insn, int op1, int op2
*** 1198,1204 ****
static void
compute_x_addr (struct prologue_value *addr,
struct prologue_value *gpr,
! unsigned 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. */
--- 1177,1183 ----
static void
compute_x_addr (struct prologue_value *addr,
struct prologue_value *gpr,
! 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. */
*************** compute_x_addr (struct prologue_value *a
*** 1221,1247 ****
#define S390_NUM_GPRS 16
#define S390_NUM_FPRS 16
/* 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. */
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 prologue_value **stack)
{
struct prologue_value gpr_spill_addr;
--- 1200,1240 ----
#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.
!
! DATA describes our current state (registers and stack slots). */
static enum pv_boolean
s390_on_stack (struct prologue_value *addr,
CORE_ADDR size,
! struct s390_prologue_data *data,
struct prologue_value **stack)
{
struct prologue_value gpr_spill_addr;
*************** s390_on_stack (struct prologue_value *ad
*** 1251,1259 ****
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];
/* 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
--- 1244,1252 ----
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 * 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
*************** s390_on_stack (struct prologue_value *ad
*** 1261,1280 ****
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);
if (b == pv_definite_yes)
{
! *stack = &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);
if (b == pv_definite_yes)
{
! *stack = &spill[14 + i];
return pv_definite_yes;
}
if (b == pv_maybe)
--- 1254,1273 ----
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, data->gpr_size, &i);
if (b == pv_definite_yes)
{
! *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, data->fpr_size, &i);
if (b == pv_definite_yes)
{
! *stack = &data->spill[14 + i];
return pv_definite_yes;
}
if (b == pv_maybe)
*************** s390_on_stack (struct prologue_value *ad
*** 1283,1292 ****
/* 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);
if (b == pv_definite_yes)
{
! *stack = back_chain;
return pv_definite_yes;
}
if (b == pv_maybe)
--- 1276,1285 ----
/* 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, data->gpr_size, &i);
if (b == pv_definite_yes)
{
! *stack = &data->back_chain;
return pv_definite_yes;
}
if (b == pv_maybe)
*************** s390_on_stack (struct prologue_value *ad
*** 1297,1372 ****
}
! /* 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
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 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;
! return on_stack;
}
-
! /* 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. */
! static void
! s390_get_signal_frame_info (struct frame_info *fi)
! {
! struct frame_info *next_frame = get_next_frame (fi);
!
! if (next_frame
! && get_frame_extra_info (next_frame)
! && get_frame_extra_info (next_frame)->sigcontext)
! {
! /* 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;
! }
! 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;
! }
}
- }
! static int
! s390_get_frame_info (CORE_ADDR start_pc,
! struct frame_extra_info *fextra_info,
! struct frame_info *fi,
! int init_extra_info)
{
/* 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 current PC for our abstract interpretation. */
CORE_ADDR pc;
--- 1290,1379 ----
}
! /* 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 s390_prologue_data *data)
{
struct prologue_value *stack;
! /* 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;
! }
!
! /* 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. */
}
! /* Do a SIZE-byte load from ADDR into VALUE. */
! static void
! s390_load (struct prologue_value *addr,
! CORE_ADDR size,
! struct prologue_value *value,
! struct s390_prologue_data *data)
! {
! struct prologue_value *stack;
! /* 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)
! {
! struct section_table *secp;
! secp = target_section_by_addr (¤t_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;
! }
! }
! /* 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);
+ }
+
! /* 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:
! 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;
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1374,1428 ****
/* 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 (i = 0; i < S390_NUM_GPRS; i++)
! pv_set_to_register (&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);
for (i = 0; i < S390_NUM_SPILL_SLOTS; i++)
! pv_set_to_unknown (&spill[i]);
! pv_set_to_unknown (&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)
{
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;
/* The values of SP, FP, and back chain before this instruction,
for detecting instructions that change them. */
--- 1381,1418 ----
/* The address of the next instruction after that. */
CORE_ADDR next_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 (&data->gpr[i], S390_R0_REGNUM + i, 0);
for (i = 0; i < S390_NUM_FPRS; i++)
! 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 (&data->spill[i]);
! pv_set_to_unknown (&data->back_chain);
}
! /* 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, x2, r3;
! int i2, d2;
/* The values of SP, FP, and back chain before this instruction,
for detecting instructions that change them. */
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1431,1612 ****
/* If we got an error trying to read the instruction, report it. */
if (insn_len < 0)
{
! result = -1;
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);
!
! /* 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);
! /* AR r1, r2 -- add register */
! else if (is_rr (insn, op_ar, &r1, &r2))
! pv_add (&gpr[r1], &gpr[r1], &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);
! /* BRAS r1, i2 --- branch relative and save */
! else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
{
! pv_set_to_constant (&gpr[r1], next_pc);
! next_pc = pc + i2 * 2;
! /* We'd better not interpret any backward branches. We'll
! never terminate. */
! if (next_pc <= pc)
! break;
}
! /* L r1, d2(x2, b2) --- load */
! else if (is_rx (insn, op_l, &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];
!
! /* 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]);
!
! /* NR r1, r2 --- logical and */
! else if (is_rr (insn, op_nr, &r1, &r2))
! pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
!
! /* 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]);
! /* NR r1, r2 --- logical and */
! else if (is_rr (insn, op_nr, &r1, &r2))
! pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
! /* S r1, d2(x2, b2) --- subtract from memory */
! else if (is_rx (insn, op_s, &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);
}
! /* ST r1, d2(x2, b2) --- store */
! else if (is_rx (insn, op_st, &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;
}
/* STD r1, d2(x2,b2) --- store floating-point register */
--- 1421,1514 ----
/* If we got an error trying to read the instruction, report it. */
if (insn_len < 0)
{
! result = 0;
break;
}
next_pc = pc + insn_len;
! 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);
!
! /* 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);
! /* LR r1, r2 --- load from register */
! else if (word_size == 4
! && is_rr (insn, op_lr, &r1, &r2))
! data->gpr[r1] = data->gpr[r2];
! /* 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];
! /* L r1, d2(x2, b2) --- load */
! else if (word_size == 4
! && is_rx (insn, op_l, &r1, &d2, &x2, &b2))
{
! struct prologue_value addr;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_load (&addr, 4, &data->gpr[r1], data);
}
! /* 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;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_load (&addr, 4, &data->gpr[r1], data);
}
! /* 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;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_load (&addr, 8, &data->gpr[r1], data);
! }
! /* ST r1, d2(x2, b2) --- store */
! else if (word_size == 4
! && is_rx (insn, op_st, &r1, &d2, &x2, &b2))
{
struct prologue_value addr;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_store (&addr, 4, &data->gpr[r1], data);
! }
! /* 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;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_store (&addr, 4, &data->gpr[r1], data);
}
! /* 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, data->gpr, d2, x2, b2);
! s390_store (&addr, 8, &data->gpr[r1], data);
}
/* STD r1, d2(x2,b2) --- store floating-point register */
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1614,1654 ****
{
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;
}
! /* 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))
{
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;
}
! /* STM r1, r3, d2(b2) --- store multiple */
! else if (is_rs (insn, op_stm, &r1, &r3, &d2, &b2))
{
int regnum;
int offset;
--- 1516,1545 ----
{
struct prologue_value addr;
! compute_x_addr (&addr, data->gpr, d2, x2, b2);
! s390_store (&addr, 8, &data->fpr[r1], data);
}
! /* 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;
! 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);
! }
}
! /* 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;
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1658,1684 ****
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;
}
-
- /* 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))
{
int regnum;
int offset;
--- 1549,1562 ----
regnum <= r3;
regnum++, offset += 4)
{
! compute_x_addr (&addr, data->gpr, d2 + offset, 0, b2);
! s390_store (&addr, 4, &data->gpr[regnum], data);
}
}
! /* 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;
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1688,1718 ****
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;
}
! /* If we left the loop early, we should stop interpreting
! altogether. */
! if (regnum <= r3)
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;
/* Record the address after the last instruction that changed
the FP, SP, or backlink. Ignore instructions that changed
--- 1566,1742 ----
regnum <= r3;
regnum++, offset += 8)
{
! 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;
!
! /* 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 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
*************** s390_get_frame_info (CORE_ADDR start_pc,
*** 1720,1914 ****
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];
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;
}
}
- /* 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;
}
/* Return true if we are in the functin's epilogue, i.e. after the
instruction that destroyed the function's stack frame. */
static int
--- 1744,1775 ----
restore instructions. (The back chain is never restored,
just popped.) */
{
! 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, &data->back_chain))
! result = next_pc;
}
}
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
*************** s390_in_function_epilogue_p (struct gdba
*** 1945,2418 ****
&& 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)
&& r3 == S390_SP_REGNUM - S390_R0_REGNUM)
return 1;
return 0;
}
static int
! s390_check_function_end (CORE_ADDR pc)
{
! bfd_byte instr[S390_MAX_INSTR_SIZE];
! int regidx, instrlen;
! instrlen = s390_readinstruction (instr, pc);
! if (instrlen < 0)
! return -1;
! /* check for BR */
! if (instrlen != 2 || instr[0] != 07 || (instr[1] >> 4) != 0xf)
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)
! 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
{
! /* Check for L */
! if (instrlen != 4 || instr[0] != 0x58)
! 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
! {
! 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);
! }
! 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 CORE_ADDR
! s390_function_start (struct frame_info *fi)
! {
! CORE_ADDR function_start = 0;
! if (get_frame_extra_info (fi) && get_frame_extra_info (fi)->initialised)
! function_start = get_frame_extra_info (fi)->function_start;
! else if (get_frame_pc (fi))
! function_start = get_frame_func (fi);
! 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;
! if (get_next_frame (fi) == NULL) /* no may be frameless */
! {
! if (get_frame_extra_info (fi))
! fextra_info_ptr = get_frame_extra_info (fi);
! else
! {
! fextra_info_ptr = &fextra_info;
! s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
! fextra_info_ptr, fi, 1);
! }
! frameless = (fextra_info_ptr->stack_bought_valid
! && fextra_info_ptr->stack_bought == 0);
! }
! return frameless;
}
! 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)))
! {
! 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;
! }
! 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)
! {
! pc = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
! /* fix signal handlers */
! }
! 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))
! {
! pc = sigcaller_pc;
! }
! return pc;
}
static void
! s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
! 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));
}
! /* 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 void
! s390_frame_init_saved_regs (struct frame_info *fi)
{
! int quick;
!
! 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);
! }
! }
}
! static CORE_ADDR
! s390_frame_saved_pc_nofix (struct frame_info *fi)
{
! if (get_frame_extra_info (fi) && get_frame_extra_info (fi)->saved_pc_valid)
! return get_frame_extra_info (fi)->saved_pc;
! 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);
!
! 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;
! }
! static CORE_ADDR
! s390_frame_saved_pc (struct frame_info *fi)
! {
! CORE_ADDR saved_pc = 0, sig_pc;
! 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);
! 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;
- }
! /* We want backtraces out of signal handlers so we don't set
! (get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
! static CORE_ADDR
! s390_frame_chain (struct frame_info *thisframe)
! {
! CORE_ADDR prev_fp = 0;
! 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);
! else
{
! int sigreturn = 0;
! CORE_ADDR sregs = 0;
! struct frame_extra_info prev_fextra_info;
! memset (&prev_fextra_info, 0, sizeof (prev_fextra_info));
! if (get_frame_pc (thisframe))
! {
! CORE_ADDR saved_pc, sig_pc;
! 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);
! }
! }
! }
}
- 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. */
! /* 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;
! CORE_ADDR pc = ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM));
! 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;
}
! static CORE_ADDR
! s390_read_fp (void)
{
! return read_register (s390_fp_regnum ());
}
! static void
! s390_pop_frame_regular (struct frame_info *frame)
{
! int regnum;
! write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
! /* 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]);
! }
! /* Throw away any cached frame information. */
! flush_cached_frames ();
}
! /* 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)
{
! /* 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);
}
--- 1806,2379 ----
&& 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_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_prologue_frame_unwind_cache (struct frame_info *next_frame,
! struct s390_unwind_cache *info)
{
! 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;
! /* Try to analyze the prologue. */
! result = s390_analyze_prologue (gdbarch, func,
! frame_pc_unwind (next_frame), &data);
! if (!result)
! return 0;
!
! /* 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;
! /* 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)
! {
! /* 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 we really have a frameless function, %r14 must be valid
+ -- in particular, it must point to a different function. */
+ frame_unwind_unsigned_register (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 ... */
+
+ 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;
+ }
+ }
+
+
+ /* OK, we've found valid prologue data. */
+ size = -sp->k;
+
+ /* 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))
+ {
+ /* 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)))
+ {
+ memset (&data, 0, sizeof (data));
+ size = 0;
+ frame_pointer = S390_SP_REGNUM;
+ }
}
!
! /* 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. */
! frame_unwind_unsigned_register (next_frame, frame_pointer, ®);
! prev_sp = reg + 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. */
!
! /* 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)
{
! struct prologue_value *slot = &data.spill[slot_num];
!
! if (slot->kind == pv_register
! && slot->k == 0)
! info->saved_regs[slot->reg].addr = slot_addr;
}
!
! /* 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)
{
! 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;
}
!
! /* 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)
! {
! if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
! || !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
! prev_sp = -1;
! }
!
! /* 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_backchain_frame_unwind_cache (struct frame_info *next_frame,
! struct s390_unwind_cache *info)
{
! 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. */
! frame_unwind_unsigned_register (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);
}
+ 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_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);
+ if (info->frame_base == -1)
+ return;
+ *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;
}
! /* 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)
{
! 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 (*this_prologue_cache)
! return *this_prologue_cache;
!
! 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. */
! frame_unwind_unsigned_register (next_frame, S390_SP_REGNUM, ®);
! info->frame_base = reg + 16*word_size + 32;
!
! return info;
}
! static void
! s390_pltstub_frame_this_id (struct frame_info *next_frame,
! void **this_prologue_cache,
! struct frame_id *this_id)
{
! 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));
}
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
! };
! 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. */
! struct s390_sigtramp_unwind_cache {
! CORE_ADDR frame_base;
! struct trad_frame_saved_reg *saved_regs;
! };
!
! static struct s390_sigtramp_unwind_cache *
! s390_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
! void **this_prologue_cache)
{
! 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;
! info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
! *this_prologue_cache = info;
! info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
! frame_unwind_unsigned_register (next_frame, S390_SP_REGNUM, &this_sp);
! 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
+ {
+ sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8, word_size);
+ }
+ /* 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]; */
+ /* 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;
! }
! /* The floating-point control word. */
! info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
! sigreg_ptr += 8;
! /* 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);
! /* Determine our frame base. */
! info->frame_base = prev_sp + 16*word_size + 32;
! return info;
! }
! static void
! s390_sigtramp_frame_this_id (struct frame_info *next_frame,
! void **this_prologue_cache,
! struct frame_id *this_id)
! {
! 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_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)
{
! CORE_ADDR pc = frame_pc_unwind (next_frame);
! bfd_byte sigreturn[2];
! if (read_memory_nobpt (pc, sigreturn, 2))
! return NULL;
! if (sigreturn[0] != 0x0a /* svc */)
! return NULL;
! if (sigreturn[1] != 119 /* sigreturn */
! && sigreturn[1] != 173 /* rt_sigreturn */)
! return NULL;
!
! return &s390_sigtramp_frame_unwind;
! }
!
!
! /* Frame base handling. */
!
! static CORE_ADDR
! s390_frame_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->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;
! frame_unwind_unsigned_register (next_frame, S390_PC_REGNUM, &pc);
! return gdbarch_addr_bits_remove (gdbarch, pc);
! }
!
! static CORE_ADDR
! s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
! ULONGEST sp;
! frame_unwind_unsigned_register (next_frame, S390_SP_REGNUM, &sp);
! return gdbarch_addr_bits_remove (gdbarch, sp);
}
*************** s390_push_dummy_call (struct gdbarch *gd
*** 2781,2788 ****
/* Store updated stack pointer. */
regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
! /* Return stack pointer. */
! return sp;
}
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
--- 2742,2751 ----
/* Store updated stack pointer. */
regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, 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
*************** s390_push_dummy_call (struct gdbarch *gd
*** 2792,2800 ****
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));
}
static CORE_ADDR
--- 2755,2766 ----
static struct frame_id
s390_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *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
*************** s390_return_value (struct gdbarch *gdbar
*** 2910,2915 ****
--- 2876,2883 ----
}
+ /* Breakpoints. */
+
static const unsigned char *
s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
*************** s390_breakpoint_from_pc (CORE_ADDR *pcpt
*** 2919,2949 ****
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));
! }
static CORE_ADDR
s390_addr_bits_remove (CORE_ADDR addr)
{
! return (addr) & 0x7fffffff;
}
static int
--- 2887,2899 ----
return breakpoint;
}
! /* Address handling. */
static CORE_ADDR
s390_addr_bits_remove (CORE_ADDR addr)
{
! return addr & 0x7fffffff;
}
static int
*************** s390_address_class_name_to_type_flags (s
*** 2977,2982 ****
--- 2927,2935 ----
return 0;
}
+
+ /* Set up gdbarch struct. */
+
static struct gdbarch *
s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
*************** s390_gdbarch_init (struct gdbarch_info i
*** 2996,3016 ****
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_frame_args_skip (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);
/* Offset from address of function to start of its code.
--- 2949,2963 ----
tdep = XCALLOC (1, struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
set_gdbarch_believe_pcc_promotion (gdbarch, 0);
set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_frame_args_skip (gdbarch, 0);
!
/* 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);
/* Stack grows downward. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
/* Offset from address of function to start of its code.
*************** s390_gdbarch_init (struct gdbarch_info i
*** 3018,3041 ****
set_gdbarch_function_start_offset (gdbarch, 0);
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_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);
--- 2965,2974 ----
set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
!
set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
set_gdbarch_sp_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);
*************** s390_gdbarch_init (struct gdbarch_info i
*** 3057,3062 ****
--- 2990,3004 ----
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:
--
Dr. Ulrich Weigand
weigand@informatik.uni-erlangen.de