/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2001 Free Software Foundation, Inc.
+
+ Copyright 2001, 2002 Free Software Foundation, Inc.
+
Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
for IBM Deutschland Entwicklung GmbH, IBM Corporation.
if ((*info->read_memory_func) (at, &instr[0], 2, info))
return -1;
instrlen = s390_instrlen[instr[0] >> 6];
- if ((*info->read_memory_func) (at + 2, &instr[2], instrlen - 2, info))
- return -1;
+ if (instrlen > 2)
+ {
+ if ((*info->read_memory_func) (at + 2, &instr[2], instrlen - 2, info))
+ return -1;
+ }
return instrlen;
}
-char *
+const char *
s390_register_name (int reg_nr)
{
static char *register_names[] = {
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
};
- if (reg_nr >= S390_LAST_REGNUM)
+ if (reg_nr <= S390_LAST_REGNUM)
+ return register_names[reg_nr];
+ else
return NULL;
- return register_names[reg_nr];
}
{
if (fi && fi->frame)
{
+ orig_sp = fi->frame;
if (! init_extra_info && fextra_info->initialised)
- orig_sp = fi->frame + fextra_info->stack_bought;
+ orig_sp += fextra_info->stack_bought;
saved_regs = fi->saved_regs;
}
if (init_extra_info || !fextra_info->initialised)
if (fi->extra_info && fi->extra_info->saved_pc_valid)
return fi->extra_info->saved_pc;
- if (generic_find_dummy_frame (fi->pc, fi->frame))
- return generic_read_register_dummy (fi->pc, fi->frame, S390_PC_REGNUM);
+ if (deprecated_generic_find_dummy_frame (fi->pc, fi->frame))
+ return deprecated_read_register_dummy (fi->pc, fi->frame, S390_PC_REGNUM);
s390_frame_init_saved_regs (fi);
if (fi->extra_info)
{
fi->extra_info->saved_pc_valid = 1;
- if (fi->extra_info->good_prologue)
- {
- if (fi->saved_regs[S390_RETADDR_REGNUM])
- {
- return (fi->extra_info->saved_pc =
- ADDR_BITS_REMOVE (read_memory_integer
- (fi->saved_regs[S390_RETADDR_REGNUM],
- S390_GPR_SIZE)));
- }
- else
- return read_register (S390_RETADDR_REGNUM);
- }
+ if (fi->extra_info->good_prologue
+ && fi->saved_regs[S390_RETADDR_REGNUM])
+ fi->extra_info->saved_pc
+ = ADDR_BITS_REMOVE (read_memory_integer
+ (fi->saved_regs[S390_RETADDR_REGNUM],
+ S390_GPR_SIZE));
+ else
+ fi->extra_info->saved_pc
+ = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
+ return fi->extra_info->saved_pc;
}
return 0;
}
{
CORE_ADDR prev_fp = 0;
- if (thisframe->prev && thisframe->prev->frame)
- prev_fp = thisframe->prev->frame;
- else if (generic_find_dummy_frame (thisframe->pc, thisframe->frame))
- return generic_read_register_dummy (thisframe->pc, thisframe->frame,
- S390_SP_REGNUM);
+ if (deprecated_generic_find_dummy_frame (thisframe->pc, thisframe->frame))
+ return deprecated_read_register_dummy (thisframe->pc, thisframe->frame,
+ S390_SP_REGNUM);
else
{
int sigreturn = 0;
/* Not the most efficent code in the world */
int
-s390_fp_regnum ()
+s390_fp_regnum (void)
{
int regno = S390_SP_REGNUM;
struct frame_extra_info fextra_info;
}
CORE_ADDR
-s390_read_fp ()
+s390_read_fp (void)
{
return read_register (s390_fp_regnum ());
}
-void
-s390_write_fp (CORE_ADDR val)
-{
- write_register (s390_fp_regnum (), val);
-}
-
-
static void
s390_pop_frame_regular (struct frame_info *frame)
{
write_register (S390_PC_REGNUM, FRAME_SAVED_PC (frame));
/* Restore any saved registers. */
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (frame->saved_regs[regnum] != 0)
- {
- ULONGEST value;
-
- value = read_memory_unsigned_integer (frame->saved_regs[regnum],
- REGISTER_RAW_SIZE (regnum));
- write_register (regnum, value);
- }
+ if (frame->saved_regs)
+ {
+ for (regnum = 0; regnum < NUM_REGS; regnum++)
+ if (frame->saved_regs[regnum] != 0)
+ {
+ ULONGEST value;
+
+ value = read_memory_unsigned_integer (frame->saved_regs[regnum],
+ 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, frame->saved_regs[S390_SP_REGNUM]);
+ /* 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, frame->saved_regs[S390_SP_REGNUM]);
+ }
/* Throw away any cached frame information. */
flush_cached_frames ();
Used in the contexts of the "return" command, and of
target function calls from the debugger. */
void
-s390_pop_frame ()
+s390_pop_frame (void)
{
/* This function checks for and handles generic dummy frames, and
calls back to our function for ordinary frames. */
/* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
defined by the parameter passing conventions described in the
- "Linux for S/390 ELF Application Binary Interface Supplement".
+ "GNU/Linux for S/390 ELF Application Binary Interface Supplement".
Otherwise, return zero. */
static int
is_double_or_float (struct type *type)
/* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
- the parameter passing conventions described in the "Linux for S/390
- ELF Application Binary Interface Supplement". Return zero otherwise. */
+ the parameter passing conventions described in the "GNU/Linux for
+ S/390 ELF Application Binary Interface Supplement". Return zero
+ otherwise. */
static int
is_simple_arg (struct type *type)
{
/* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
- parameter passing conventions described in the "Linux for S/390 ELF
- Application Binary Interface Supplement". Return zero otherwise. */
+ parameter passing conventions described in the "GNU/Linux for S/390
+ ELF Application Binary Interface Supplement". Return zero
+ otherwise. */
static int
is_double_arg (struct type *type)
{
/* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
- place to be passed to a function, as specified by the "Linux for
- S/390 ELF Application Binary Interface Supplement".
+ place to be passed to a function, as specified by the "GNU/Linux
+ for S/390 ELF Application Binary Interface Supplement".
SP is the current stack pointer. We must put arguments, links,
padding, etc. whereever they belong, and return the new stack
else if (is_double_arg (type)
&& gr <= 5)
{
- write_register_gen (S390_GP0_REGNUM + gr,
- VALUE_CONTENTS (arg));
- write_register_gen (S390_GP0_REGNUM + gr + 1,
- VALUE_CONTENTS (arg) + 4);
+ deprecated_write_register_gen (S390_GP0_REGNUM + gr,
+ VALUE_CONTENTS (arg));
+ deprecated_write_register_gen (S390_GP0_REGNUM + gr + 1,
+ VALUE_CONTENTS (arg) + 4);
gr += 2;
}
else
struct type *
s390_register_virtual_type (int regno)
{
- return ((unsigned) regno - S390_FPC_REGNUM) <
- S390_NUM_FPRS ? builtin_type_double : builtin_type_int;
+ if (S390_FP0_REGNUM <= regno && regno < S390_FP0_REGNUM + S390_NUM_FPRS)
+ return builtin_type_double;
+ else
+ return builtin_type_int;
}
-static unsigned char *
+const static unsigned char *
s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
static unsigned char breakpoint[] = { 0x0, 0x1 };
gdbarch = gdbarch_alloc (&info, NULL);
set_gdbarch_believe_pcc_promotion (gdbarch, 0);
+ set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frame_args_address (gdbarch, s390_frame_args_address);
/* We can't do this */
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
set_gdbarch_store_struct_return (gdbarch, s390_store_struct_return);
- set_gdbarch_extract_return_value (gdbarch, s390_extract_return_value);
- set_gdbarch_store_return_value (gdbarch, s390_store_return_value);
+ set_gdbarch_deprecated_extract_return_value (gdbarch, s390_extract_return_value);
+ set_gdbarch_deprecated_store_return_value (gdbarch, s390_store_return_value);
/* Amount PC must be decremented by after a breakpoint.
This is often the number of bytes in BREAKPOINT
but not always. */
set_gdbarch_decr_pc_after_break (gdbarch, 2);
set_gdbarch_pop_frame (gdbarch, s390_pop_frame);
- set_gdbarch_ieee_float (gdbarch, 1);
/* Stack grows downward. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
/* Offset from address of function to start of its code.
set_gdbarch_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
set_gdbarch_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
set_gdbarch_read_fp (gdbarch, s390_read_fp);
- set_gdbarch_write_fp (gdbarch, s390_write_fp);
/* 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_num_regs (gdbarch, S390_NUM_REGS);
set_gdbarch_cannot_fetch_register (gdbarch, s390_cannot_fetch_register);
set_gdbarch_cannot_store_register (gdbarch, s390_cannot_fetch_register);
- set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
+ set_gdbarch_get_saved_register (gdbarch, generic_unwind_get_saved_register);
set_gdbarch_use_struct_convention (gdbarch, s390_use_struct_convention);
set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
set_gdbarch_register_name (gdbarch, s390_register_name);
set_gdbarch_stab_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
- set_gdbarch_extract_struct_value_address
+ set_gdbarch_deprecated_extract_struct_value_address
(gdbarch, generic_cannot_extract_struct_value_address);
/* Parameters for inferior function calls. */
switch (info.bfd_arch_info->mach)
{
- case bfd_mach_s390_esa:
+ case bfd_mach_s390_31:
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_register_raw_size (gdbarch, s390_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, s390_register_raw_size);
set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
set_gdbarch_register_bytes (gdbarch, S390_REGISTER_BYTES);
break;
- case bfd_mach_s390_esame:
+ case bfd_mach_s390_64:
set_gdbarch_register_size (gdbarch, 8);
set_gdbarch_register_raw_size (gdbarch, s390x_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, s390x_register_raw_size);
void
-_initialize_s390_tdep ()
+_initialize_s390_tdep (void)
{
/* Hook us into the gdbarch mechanism. */