/* Target-dependent code for Renesas Super-H, for GDB.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "frame.h"
#include "symtab.h"
-#include "symfile.h"
+#include "objfiles.h"
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "gdbcore.h"
};
static const char *
-sh_sh64_register_name (int reg_nr)
+sh64_register_name (int reg_nr)
{
static char *register_names[] =
{
}
static const unsigned char *
-sh_sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
/* The BRK instruction for shmedia is
01101111 11110101 11111111 11110000
static int
translate_insn_rn (int rn, int media_mode)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
/* FIXME: this assumes that the number rn is for a not pseudo
register only. */
if (media_mode)
static CORE_ADDR
sh64_frame_chain (struct frame_info *frame)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
- get_frame_base (frame),
- get_frame_base (frame)))
+ if (deprecated_pc_in_call_dummy (get_frame_pc (frame)))
return get_frame_base (frame); /* dummy frame same as caller's frame */
- if (get_frame_pc (frame)
- && !deprecated_inside_entry_file (get_frame_pc (frame)))
+ if (get_frame_pc (frame))
{
int media_mode = pc_is_isa32 (get_frame_pc (frame));
int size;
int media_mode = 0;
for (; fi; fi = get_next_frame (fi))
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
- get_frame_base (fi)))
+ if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
/* When the caller requests PR from the dummy frame, we return
PC because that's where the previous routine appears to have
done a call from. */
static int
is_media_pseudo (int rn)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
- return (rn >= DR0_REGNUM
- && rn <= FV_LAST_REGNUM);
-}
-
-static int
-sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc)
-{
- return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc));
+ return (rn >= DR0_REGNUM && rn <= FV_LAST_REGNUM);
}
static int
sh64_media_reg_base_num (int reg_nr)
{
int base_regnum = -1;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
sh64_compact_reg_base_num (int reg_nr)
{
int base_regnum = -1;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* general register N maps to general register N */
if (reg_nr >= R0_C_REGNUM
int insn_size;
int gdb_register_number;
int register_number;
- char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), get_frame_base (fi));
+ char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi),
+ get_frame_base (fi));
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (deprecated_get_frame_saved_regs (fi) == NULL)
if (get_next_frame (fi))
deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
- get_frame_base (fi)))
+ if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
{
/* We need to setup fi->frame here because call_function_by_hand
gets it wrong by assuming it's always FP. */
get_frame_extra_info (fi)->return_pc =
deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), PC_REGNUM);
- get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
+ get_frame_extra_info (fi)->f_offset = -4;
get_frame_extra_info (fi)->leaf_function = 0;
return;
}
while (frame && ((frame = get_next_frame (frame)) != NULL))
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
- get_frame_base (frame),
- get_frame_base (frame)))
+ if (deprecated_pc_in_call_dummy (get_frame_pc (frame)))
{
if (lval) /* found it in a CALL_DUMMY frame */
*lval = not_lval;
else
size = register_size (current_gdbarch, live_regnum);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
- read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
+ read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
+ raw_buffer, size);
else
read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
raw_buffer
}
static CORE_ADDR
-sh64_extract_struct_value_address (char *regbuf)
+sh64_extract_struct_value_address (struct regcache *regcache)
{
- return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
- register_size (current_gdbarch,
- STRUCT_RETURN_REGNUM)));
+ /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return
+ address regster is preserved across function calls? Probably
+ not, making this function wrong. */
+ ULONGEST val;
+ regcache_raw_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &val);
+ return val;
}
static CORE_ADDR
int media_mode = pc_is_isa32 (get_frame_pc (frame));
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
- get_frame_base (frame),
- get_frame_base (frame)))
- generic_pop_dummy_frame ();
+ if (deprecated_pc_in_call_dummy (get_frame_pc (frame)))
+ deprecated_pop_dummy_frame ();
else
{
fp = get_frame_base (frame);
int len;
int argreg_size;
int fp_args[12];
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
memset (fp_args, 0, sizeof (fp_args));
/* Now make sure there's space on the stack */
for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
- stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 7) & ~7);
+ stack_alloc += ((TYPE_LENGTH (value_type (args[argnum])) + 7) & ~7);
sp -= stack_alloc; /* make room on stack for args */
/* Now load as many as possible of the first arguments into
for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
{
- type = VALUE_TYPE (args[argnum]);
+ type = value_type (args[argnum]);
len = TYPE_LENGTH (type);
memset (valbuf, 0, sizeof (valbuf));
/* value gets right-justified in the register or stack word */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
memcpy (valbuf + argreg_size - len,
- (char *) VALUE_CONTENTS (args[argnum]), len);
+ (char *) value_contents (args[argnum]), len);
else
- memcpy (valbuf, (char *) VALUE_CONTENTS (args[argnum]), len);
+ memcpy (valbuf, (char *) value_contents (args[argnum]), len);
val = valbuf;
}
else
- val = (char *) VALUE_CONTENTS (args[argnum]);
+ val = (char *) value_contents (args[argnum]);
while (len > 0)
{
}
else
{
- val = (char *) VALUE_CONTENTS (args[argnum]);
+ val = (char *) value_contents (args[argnum]);
if (len == 4)
{
/* Where is it going to be stored? */
int offset;
int return_register;
int len = TYPE_LENGTH (type);
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
sh64_show_media_regs (void)
{
int i;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
printf_filtered ("PC=%s SR=%016llx \n",
paddr (read_register (PC_REGNUM)),
sh64_show_compact_regs (void)
{
int i;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
printf_filtered ("PC=%s \n",
paddr (read_register (PC_C_REGNUM)));
*/
/* *INDENT-ON* */
static int
-sh_sh64_register_byte (int reg_nr)
+sh64_register_byte (int reg_nr)
{
int base_regnum = -1;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* If it is a pseudo register, get the number of the first floating
point register that is part of it. */
}
static struct type *
-sh_sh64_build_float_register_type (int high)
+sh64_build_float_register_type (int high)
{
struct type *temp;
static struct type *
sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
if ((reg_nr >= FP0_REGNUM
&& reg_nr <= FP_LAST_REGNUM)
|| (reg_nr >= FP0_C_REGNUM
return builtin_type_double;
else if (reg_nr >= FPP0_REGNUM
&& reg_nr <= FPP_LAST_REGNUM)
- return sh_sh64_build_float_register_type (1);
+ return sh64_build_float_register_type (1);
else if ((reg_nr >= FV0_REGNUM
&& reg_nr <= FV_LAST_REGNUM)
||(reg_nr >= FV0_C_REGNUM
&& reg_nr <= FV_LAST_C_REGNUM))
- return sh_sh64_build_float_register_type (3);
+ return sh64_build_float_register_type (3);
else if (reg_nr == FPSCR_REGNUM)
return builtin_type_int;
else if (reg_nr >= R0_C_REGNUM
}
static void
-sh_sh64_register_convert_to_virtual (int regnum, struct type *type,
+sh64_register_convert_to_virtual (int regnum, struct type *type,
char *from, char *to)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
{
/* It is a no-op. */
DOUBLEST val;
floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
from, &val);
- store_typed_floating(to, type, val);
+ store_typed_floating (to, type, val);
}
else
- error("sh64_register_convert_to_virtual called with non DR register number");
+ error ("sh64_register_convert_to_virtual called with non DR register number");
}
static void
-sh_sh64_register_convert_to_raw (struct type *type, int regnum,
+sh64_register_convert_to_raw (struct type *type, int regnum,
const void *from, void *to)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
{
/* It is a no-op. */
&val, to);
}
else
- error("sh64_register_convert_to_raw called with non DR register number");
+ error ("sh64_register_convert_to_raw called with non DR register number");
}
static void
int portion;
int offset = 0;
char temp_buffer[MAX_REGISTER_SIZE];
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
+ register_size (gdbarch, base_regnum) * portion));
/* We must pay attention to the endianness. */
- sh_sh64_register_convert_to_virtual (reg_nr,
- gdbarch_register_type (gdbarch,
- reg_nr),
- temp_buffer, buffer);
+ sh64_register_convert_to_virtual (reg_nr,
+ gdbarch_register_type (gdbarch,
+ reg_nr),
+ temp_buffer, buffer);
}
+ register_size (gdbarch, base_regnum) * portion));
/* We must pay attention to the endianness. */
- sh_sh64_register_convert_to_virtual (reg_nr,
- gdbarch_register_type (gdbarch,
- reg_nr),
- temp_buffer, buffer);
+ sh64_register_convert_to_virtual (reg_nr,
+ gdbarch_register_type (gdbarch,
+ reg_nr),
+ temp_buffer, buffer);
}
else if (reg_nr >= FV0_C_REGNUM
int base_regnum, portion;
int offset;
char temp_buffer[MAX_REGISTER_SIZE];
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
{
base_regnum = dr_reg_base_num (reg_nr);
/* We must pay attention to the endianness. */
- sh_sh64_register_convert_to_raw (gdbarch_register_type (gdbarch,
- reg_nr), reg_nr,
- buffer, temp_buffer);
-
+ sh64_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr),
+ reg_nr,
+ buffer, temp_buffer);
/* Write the real regs for which this one is an alias. */
for (portion = 0; portion < 2; portion++)
for (portion = 0; portion < 2; portion++)
{
/* We must pay attention to the endianness. */
- sh_sh64_register_convert_to_raw (gdbarch_register_type (gdbarch,
- reg_nr),
- reg_nr,
- buffer, temp_buffer);
+ sh64_register_convert_to_raw (gdbarch_register_type (gdbarch,
+ reg_nr),
+ reg_nr,
+ buffer, temp_buffer);
regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
/* Get the data in raw format. */
- if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
+ if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
/* Get the register as a number */
sh64_do_pseudo_register (int regnum)
{
/* All the sh64-compact mode registers are pseudo registers. */
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (regnum < NUM_REGS
|| regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT)
internal_error (__FILE__, __LINE__,
- "Invalid pseudo register number %d\n", regnum);
+ _("Invalid pseudo register number %d\n"), regnum);
else if ((regnum >= DR0_REGNUM
&& regnum <= DR_LAST_REGNUM))
print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
/* Get the data in raw format. */
- if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
+ if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
fprintf_filtered (file, "*value not available*\n");
val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
{
if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
internal_error (__FILE__, __LINE__,
- "Invalid register number %d\n", regnum);
+ _("Invalid register number %d\n"), regnum);
else if (regnum >= 0 && regnum < NUM_REGS)
{
static void
sh_compact_do_registers_info (int regnum, int fpregs)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (regnum != -1) /* do one specified register */
{
if (*(REGISTER_NAME (regnum)) == '\0')
sh_compact_do_registers_info (regnum, fpregs);
}
-#ifdef SVR4_SHARED_LIBS
-
/* Fetch (and possibly build) an appropriate link_map_offsets structure
for native i386 linux targets using the struct offsets defined in
link.h (but without actual reference to that file).
return lmp;
}
-#endif /* SVR4_SHARED_LIBS */
gdbarch_init_ftype sh64_gdbarch_init;
struct gdbarch *
sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
- static LONGEST sh64_call_dummy_words[] = {0};
struct gdbarch *gdbarch;
struct gdbarch_tdep *tdep;
set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_decr_pc_after_break (gdbarch, 0);
- set_gdbarch_function_start_offset (gdbarch, 0);
- set_gdbarch_frame_args_skip (gdbarch, 0);
- set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, sh_frame_saved_pc);
/* The number of real registers is the same whether we are in
ISA16(compact) or ISA32(media). */
set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
- set_gdbarch_deprecated_register_bytes (gdbarch,
- ((SIM_SH64_NR_FP_REGS + 1) * 4)
- + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
- set_gdbarch_register_name (gdbarch, sh_sh64_register_name);
+ set_gdbarch_register_name (gdbarch, sh64_register_name);
set_gdbarch_register_type (gdbarch, sh64_register_type);
set_gdbarch_deprecated_store_return_value (gdbarch, sh64_store_return_value);
- set_gdbarch_deprecated_register_byte (gdbarch, sh_sh64_register_byte);
+ set_gdbarch_deprecated_register_byte (gdbarch, sh64_register_byte);
set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
- set_gdbarch_breakpoint_from_pc (gdbarch, sh_sh64_breakpoint_from_pc);
- set_gdbarch_deprecated_call_dummy_words (gdbarch, sh64_call_dummy_words);
- set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh64_call_dummy_words));
+ set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
set_gdbarch_deprecated_frame_chain (gdbarch, sh64_frame_chain);
set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address);
- set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention);
+ set_gdbarch_deprecated_use_struct_convention (gdbarch, sh64_use_struct_convention);
set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame);
set_gdbarch_elf_make_msymbol_special (gdbarch,
sh64_elf_make_msymbol_special);
projects / deliverable / binutils-gdb.git / blobdiff