#include "regcache.h"
#include "value.h"
#include "gdb_assert.h"
-
+#include "dis-asm.h"
&& get_frame_extra_info (next_frame)->sigcontext)
{
/* We're definitely backtracing from a signal handler. */
- CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
+ CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
- + REGISTER_BYTE (S390_GP0_REGNUM));
+ + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM));
int reg;
for (reg = 0; reg < S390_NUM_GPRS; reg++)
- the analysis gave us enough information to actually figure it
out. */
if (fi
- && get_frame_saved_regs (fi)
+ && deprecated_get_frame_saved_regs (fi)
&& original_sp != -1)
{
int slot_num;
CORE_ADDR slot_addr;
- CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
+ 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
*sigcaller_pc =
ADDR_BITS_REMOVE ((CORE_ADDR)
read_memory_integer (temp_sregs +
- REGISTER_BYTE
- (S390_PC_REGNUM),
+ DEPRECATED_REGISTER_BYTE (S390_PC_REGNUM),
S390_PSW_ADDR_SIZE));
}
}
int quick;
- if (get_frame_saved_regs (fi) == NULL)
+ if (deprecated_get_frame_saved_regs (fi) == NULL)
{
/* zalloc memsets the saved regs */
frame_saved_regs_zalloc (fi);
{
get_frame_extra_info (fi)->saved_pc_valid = 1;
if (get_frame_extra_info (fi)->good_prologue
- && get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
+ && deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
get_frame_extra_info (fi)->saved_pc
= ADDR_BITS_REMOVE (read_memory_integer
- (get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
+ (deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
S390_GPR_SIZE));
else
get_frame_extra_info (fi)->saved_pc
{
/* read sigregs,regs.gprs[11 or 15] */
prev_fp = read_memory_integer (sregs +
- REGISTER_BYTE (S390_GP0_REGNUM +
+ DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM +
(prev_fextra_info.
frame_pointer_saved_pc
? 11 : 15)),
}
else
{
- if (get_frame_saved_regs (thisframe))
+ if (deprecated_get_frame_saved_regs (thisframe))
{
int regno;
if (prev_fextra_info.frame_pointer_saved_pc
- && get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
+ && deprecated_get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
regno = S390_FRAME_REGNUM;
else
regno = S390_SP_REGNUM;
- if (get_frame_saved_regs (thisframe)[regno])
+ if (deprecated_get_frame_saved_regs (thisframe)[regno])
{
/* The SP's entry of `saved_regs' is special. */
if (regno == S390_SP_REGNUM)
- prev_fp = get_frame_saved_regs (thisframe)[regno];
+ prev_fp = deprecated_get_frame_saved_regs (thisframe)[regno];
else
prev_fp =
- read_memory_integer (get_frame_saved_regs (thisframe)[regno],
+ read_memory_integer (deprecated_get_frame_saved_regs (thisframe)[regno],
S390_GPR_SIZE);
}
}
+/* NOTE: cagney/2003-10-31: "return_value" makes
+ "extract_struct_value_address", "extract_return_value", and
+ "use_struct_convention" redundant. */
+static CORE_ADDR
+s390_cannot_extract_struct_value_address (struct regcache *regcache)
+{
+ return 0;
+}
+
/* a given return value in `regbuf' with a type `valtype', extract and copy its
value into `valbuf' */
static void
int len = TYPE_LENGTH (valtype);
if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
- memcpy (valbuf, ®buf[REGISTER_BYTE (S390_FP0_REGNUM)], len);
+ memcpy (valbuf, ®buf[DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM)], len);
else
{
int offset = 0;
if (TYPE_LENGTH (valtype) < S390_GPR_SIZE)
offset = S390_GPR_SIZE - TYPE_LENGTH (valtype);
memcpy (valbuf,
- regbuf + REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
+ regbuf + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
TYPE_LENGTH (valtype));
}
}
{
if (TYPE_LENGTH (valtype) == 4
|| TYPE_LENGTH (valtype) == 8)
- deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM),
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM),
valbuf, TYPE_LENGTH (valtype));
else
error ("GDB is unable to return `long double' values "
value =
s390_promote_integer_argument (valtype, valbuf, reg_buff, &arglen);
/* Everything else is returned in GPR2 and up. */
- deprecated_write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM + 2),
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM + 2),
value, arglen);
}
}
write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
/* Restore any saved registers. */
- if (get_frame_saved_regs (frame))
+ if (deprecated_get_frame_saved_regs (frame))
{
for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (get_frame_saved_regs (frame)[regnum] != 0)
+ if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
ULONGEST value;
- value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
- REGISTER_RAW_SIZE (regnum));
+ 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, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
+ write_register (S390_SP_REGNUM, deprecated_get_frame_saved_regs (frame)[S390_SP_REGNUM]);
}
/* Throw away any cached frame information. */
}
-/* Round ADDR up to the next N-byte boundary. N must be a power of
- two. */
-static CORE_ADDR
-round_up (CORE_ADDR addr, int n)
-{
- /* Check that N is really a power of two. */
- gdb_assert (n && (n & (n-1)) == 0);
- return ((addr + n - 1) & -n);
-}
-
-
-/* Round ADDR down to the next N-byte boundary. N must be a power of
- two. */
-static CORE_ADDR
-round_down (CORE_ADDR addr, int n)
-{
- /* Check that N is really a power of two. */
- gdb_assert (n && (n & (n-1)) == 0);
- return (addr & -n);
-}
-
-
/* Return the alignment required by TYPE. */
static int
alignment_of (struct type *type)
&& pass_by_copy_ref (type))
{
sp -= length;
- sp = round_down (sp, alignment_of (type));
+ sp = align_down (sp, alignment_of (type));
write_memory (sp, VALUE_CONTENTS (arg), length);
copy_addr[i] = sp;
num_copies++;
struct type *type = VALUE_TYPE (arg);
int length = TYPE_LENGTH (type);
- sp = round_down (sp, alignment_of (type));
+ sp = align_down (sp, alignment_of (type));
/* SIMPLE_ARG values get extended to DEPRECATED_REGISTER_SIZE bytes.
Assume every argument is. */
}
/* Include space for any reference-to-copy pointers. */
- sp = round_down (sp, pointer_size);
+ sp = align_down (sp, pointer_size);
sp -= num_copies * pointer_size;
/* After all that, make sure it's still aligned on an eight-byte
boundary. */
- sp = round_down (sp, 8);
+ sp = align_down (sp, 8);
/* Finally, place the actual parameters, working from SP towards
higher addresses. The code above is supposed to reserve enough
{
/* When we store a single-precision value in an FP register,
it occupies the leftmost bits. */
- deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM + fr),
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM + fr),
VALUE_CONTENTS (arg),
TYPE_LENGTH (type));
fr += 2;
{
/* Simple args are always extended to
DEPRECATED_REGISTER_SIZE bytes. */
- starg = round_up (starg, DEPRECATED_REGISTER_SIZE);
+ starg = align_up (starg, DEPRECATED_REGISTER_SIZE);
/* Do we need to pass a pointer to our copy of this
argument? */
else
{
/* You'd think we should say:
- starg = round_up (starg, alignment_of (type));
+ starg = align_up (starg, alignment_of (type));
Unfortunately, GCC seems to simply align the stack on
a four/eight-byte boundary, even when passing doubles. */
- starg = round_up (starg, S390_STACK_PARAMETER_ALIGNMENT);
+ starg = align_up (starg, S390_STACK_PARAMETER_ALIGNMENT);
write_memory (starg, VALUE_CONTENTS (arg), length);
starg += length;
}
static CORE_ADDR
s390_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
- write_register (S390_RETADDR_REGNUM, CALL_DUMMY_ADDRESS ());
+ write_register (S390_RETADDR_REGNUM, entry_point_address ());
return sp;
}
/* 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, init_frame_pc_default);
+ set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
set_gdbarch_believe_pcc_promotion (gdbarch, 0);
set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_deprecated_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.
- Zero on most machines. */
- set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
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_deprecated_extract_struct_value_address
- (gdbarch, generic_cannot_extract_struct_value_address);
+ set_gdbarch_deprecated_extract_struct_value_address (gdbarch, s390_cannot_extract_struct_value_address);
/* Parameters for inferior function calls. */
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
projects / deliverable / binutils-gdb.git / blobdiff