This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[PATCH] Partial de-depricatification of sh64-tdep.c
- From: Michael Snyder <msnyder at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Cc: Elena Zannoni <ezannoni at redhat dot com>, joern dot rennecke at superh dot com
- Date: Wed, 12 Nov 2003 14:23:04 -0800
- Subject: [PATCH] Partial de-depricatification of sh64-tdep.c
- Organization: Red Hat, Inc.
This patch gets rid of at least three deprecated functions or macros.
I've tested it as well as I can, given that the current sh64 sim
doesn't build. This compiles without warnings, and it tests out OK
on an older branch that I have in which the sim does build.
2003-11-12 Michael Snyder <msnyder@redhat.com>
* sh64-tdep.c: Coding standard and spelling comment fixes.
(sh64_extract_return_value): Replace deprecated_store_floating
with store_typed_floating.
(sh_sh64_register_convert_to_raw): Replace
deprecated_store_floating with store_typed_floating.
(sh_sh64_register_virtual_type): Convert to sh64_register_type.
(sh64_frame_chain, sh64_get_saved_pr, sh64_get_saved_register,
sh64_nofp_frame_init_saved_regs, sh64_push_arguments,
sh64_extract_struct_value_address, sh64_pop_frame,
sh64_extract_return_value, sh64_store_return_value,
sh_sh64_register_convert_to_virtual, sh64_pseudo_register_read,
sh_sh64_register_convert_to_raw, sh_pseudo_register_write):
Replace DEPRECATED_REGISTER_RAW_SIZE with register_size.
Replace DEPRECATED_REGISTER_VIRTUAL_TYPE with register_type.
(sh64_gdbarch_init): Don't set deprecated_register_bytes,
deprecated_register_virtual_type, deprecated_register_raw_size,
deprecated_max_register_raw_size, or
deprecated_max_register_virtual_size. Instead, just set
gdbarch_register_type.
Index: sh64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh64-tdep.c,v
retrieving revision 1.12
diff -p -r1.12 sh64-tdep.c
*** sh64-tdep.c 11 Nov 2003 20:04:52 -0000 1.12
--- sh64-tdep.c 12 Nov 2003 21:52:20 -0000
***************
*** 49,55 ****
/* registers numbers shared with the simulator */
#include "gdb/sim-sh.h"
! /* Information that is dependent on the processor variant. */
enum sh_abi
{
SH_ABI_UNKNOWN,
--- 49,55 ----
/* registers numbers shared with the simulator */
#include "gdb/sim-sh.h"
! /* Information that is dependent on the processor variant. */
enum sh_abi
{
SH_ABI_UNKNOWN,
*************** enum
*** 78,84 ****
/* FPP stands for Floating Point Pair, to avoid confusion with
GDB's FP0_REGNUM, which is the number of the first Floating
point register. Unfortunately on the sh5, the floating point
! registers are called FR, and the floating point pairs are called FP. */
FPP0_REGNUM = 173,
FPP_LAST_REGNUM = 204,
FV0_REGNUM = 205,
--- 78,84 ----
/* FPP stands for Floating Point Pair, to avoid confusion with
GDB's FP0_REGNUM, which is the number of the first Floating
point register. Unfortunately on the sh5, the floating point
! registers are called FR, and the floating point pairs are called FP. */
FPP0_REGNUM = 173,
FPP_LAST_REGNUM = 204,
FV0_REGNUM = 205,
*************** pc_is_isa32 (bfd_vma memaddr)
*** 233,239 ****
struct minimal_symbol *sym;
/* If bit 0 of the address is set, assume this is a
! ISA32 (shmedia) address. */
if (IS_ISA32_ADDR (memaddr))
return 1;
--- 233,239 ----
struct minimal_symbol *sym;
/* If bit 0 of the address is set, assume this is a
! ISA32 (shmedia) address. */
if (IS_ISA32_ADDR (memaddr))
return 1;
*************** sh_sh64_breakpoint_from_pc (CORE_ADDR *p
*** 392,405 ****
#define IS_MOV_R14_R0(x) ((x) == 0x20e6)
/* ADD Rm,R63,Rn Rm+R63-->Rn 0000 00mm mmmm 1001 1111 11nn nnnn 0000
! where Rm is one of r2-r9 which are the argument registers. */
/* FIXME: Recognize the float and double register moves too! */
#define IS_MEDIA_IND_ARG_MOV(x) \
((((x) & 0xfc0ffc0f) == 0x0009fc00) && (((x) & 0x03f00000) >= 0x00200000 && ((x) & 0x03f00000) <= 0x00900000))
/* ST.Q Rn,0,Rm Rm-->Rn+0 1010 11nn nnnn 0000 0000 00mm mmmm 0000
or ST.L Rn,0,Rm Rm-->Rn+0 1010 10nn nnnn 0000 0000 00mm mmmm 0000
! where Rm is one of r2-r9 which are the argument registers. */
#define IS_MEDIA_ARG_MOV(x) \
(((((x) & 0xfc0ffc0f) == 0xac000000) || (((x) & 0xfc0ffc0f) == 0xa8000000)) \
&& (((x) & 0x000003f0) >= 0x00000020 && ((x) & 0x000003f0) <= 0x00000090))
--- 392,405 ----
#define IS_MOV_R14_R0(x) ((x) == 0x20e6)
/* ADD Rm,R63,Rn Rm+R63-->Rn 0000 00mm mmmm 1001 1111 11nn nnnn 0000
! where Rm is one of r2-r9 which are the argument registers. */
/* FIXME: Recognize the float and double register moves too! */
#define IS_MEDIA_IND_ARG_MOV(x) \
((((x) & 0xfc0ffc0f) == 0x0009fc00) && (((x) & 0x03f00000) >= 0x00200000 && ((x) & 0x03f00000) <= 0x00900000))
/* ST.Q Rn,0,Rm Rm-->Rn+0 1010 11nn nnnn 0000 0000 00mm mmmm 0000
or ST.L Rn,0,Rm Rm-->Rn+0 1010 10nn nnnn 0000 0000 00mm mmmm 0000
! where Rm is one of r2-r9 which are the argument registers. */
#define IS_MEDIA_ARG_MOV(x) \
(((((x) & 0xfc0ffc0f) == 0xac000000) || (((x) & 0xfc0ffc0f) == 0xa8000000)) \
&& (((x) & 0x000003f0) >= 0x00000020 && ((x) & 0x000003f0) <= 0x00000090))
*************** sh_sh64_breakpoint_from_pc (CORE_ADDR *p
*** 446,452 ****
/* Skip any prologue before the guts of a function */
/* Skip the prologue using the debug information. If this fails we'll
! fall back on the 'guess' method below. */
static CORE_ADDR
after_prologue (CORE_ADDR pc)
{
--- 446,452 ----
/* Skip any prologue before the guts of a function */
/* Skip the prologue using the debug information. If this fails we'll
! fall back on the 'guess' method below. */
static CORE_ADDR
after_prologue (CORE_ADDR pc)
{
*************** look_for_args_moves (CORE_ADDR start_pc,
*** 490,496 ****
{
/* This must be followed by a store to r14, so the argument
is where the debug info says it is. This can happen after
! the SP has been saved, unfortunately. */
int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
insn_size);
--- 490,496 ----
{
/* This must be followed by a store to r14, so the argument
is where the debug info says it is. This can happen after
! the SP has been saved, unfortunately. */
int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
insn_size);
*************** look_for_args_moves (CORE_ADDR start_pc,
*** 500,506 ****
}
else if (IS_MEDIA_ARG_MOV (w))
{
! /* These instructions store directly the argument in r14. */
start_pc = here;
}
else
--- 500,506 ----
}
else if (IS_MEDIA_ARG_MOV (w))
{
! /* These instructions store directly the argument in r14. */
start_pc = here;
}
else
*************** look_for_args_moves (CORE_ADDR start_pc,
*** 515,521 ****
{
/* This must be followed by a store to r14, so the argument
is where the debug info says it is. This can happen after
! the SP has been saved, unfortunately. */
int next_insn = 0xffff & read_memory_integer (here, insn_size);
here += insn_size;
--- 515,521 ----
{
/* This must be followed by a store to r14, so the argument
is where the debug info says it is. This can happen after
! the SP has been saved, unfortunately. */
int next_insn = 0xffff & read_memory_integer (here, insn_size);
here += insn_size;
*************** look_for_args_moves (CORE_ADDR start_pc,
*** 524,530 ****
}
else if (IS_COMPACT_ARG_MOV (w))
{
! /* These instructions store directly the argument in r14. */
start_pc = here;
}
else if (IS_MOVL_R0 (w))
--- 524,530 ----
}
else if (IS_COMPACT_ARG_MOV (w))
{
! /* These instructions store directly the argument in r14. */
start_pc = here;
}
else if (IS_MOVL_R0 (w))
*************** look_for_args_moves (CORE_ADDR start_pc,
*** 545,551 ****
stack slot in the register. GCC thinks the argument is
just passed by transparent reference, but this is only
true after the argument decoder is called. Such a call
! needs to be considered part of the prologue. */
/* This must be followed by a JSR @r0 instruction and by
a NOP instruction. After these, the prologue is over! */
--- 545,551 ----
stack slot in the register. GCC thinks the argument is
just passed by transparent reference, but this is only
true after the argument decoder is called. Such a call
! needs to be considered part of the prologue. */
/* This must be followed by a JSR @r0 instruction and by
a NOP instruction. After these, the prologue is over! */
*************** sh64_skip_prologue_hard_way (CORE_ADDR s
*** 609,615 ****
{
/* Don't bail out yet, we may have arguments stored in
registers here, according to the debug info, so that
! gdb can print the frames correctly. */
start_pc = look_for_args_moves (here - insn_size, media_mode);
break;
}
--- 609,615 ----
{
/* Don't bail out yet, we may have arguments stored in
registers here, according to the debug info, so that
! gdb can print the frames correctly. */
start_pc = look_for_args_moves (here - insn_size, media_mode);
break;
}
*************** sh64_skip_prologue_hard_way (CORE_ADDR s
*** 635,641 ****
{
/* Don't bail out yet, we may have arguments stored in
registers here, according to the debug info, so that
! gdb can print the frames correctly. */
start_pc = look_for_args_moves (here - insn_size, media_mode);
break;
}
--- 635,641 ----
{
/* Don't bail out yet, we may have arguments stored in
registers here, according to the debug info, so that
! gdb can print the frames correctly. */
start_pc = look_for_args_moves (here - insn_size, media_mode);
break;
}
*************** sh_skip_prologue (CORE_ADDR pc)
*** 656,662 ****
post_prologue_pc = after_prologue (pc);
/* If after_prologue returned a useful address, then use it. Else
! fall back on the instruction skipping code. */
if (post_prologue_pc != 0)
return max (pc, post_prologue_pc);
else
--- 656,662 ----
post_prologue_pc = after_prologue (pc);
/* If after_prologue returned a useful address, then use it. Else
! fall back on the instruction skipping code. */
if (post_prologue_pc != 0)
return max (pc, post_prologue_pc);
else
*************** gdb_print_insn_sh (bfd_vma memaddr, disa
*** 702,721 ****
/* Given a register number RN as it appears in an assembly
instruction, find the corresponding register number in the GDB
! scheme. */
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)
return rn;
else
{
! /* These registers don't have a corresponding compact one. */
! /* FIXME: This is probably not enough. */
#if 0
if ((rn >= 16 && rn <= 63) || (rn >= 93 && rn <= 140))
return rn;
--- 702,721 ----
/* Given a register number RN as it appears in an assembly
instruction, find the corresponding register number in the GDB
! scheme. */
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)
return rn;
else
{
! /* These registers don't have a corresponding compact one. */
! /* FIXME: This is probably not enough. */
#if 0
if ((rn >= 16 && rn <= 63) || (rn >= 93 && rn <= 140))
return rn;
*************** sh64_frame_chain (struct frame_info *fra
*** 740,746 ****
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
get_frame_base (frame),
get_frame_base (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)))
{
--- 740,746 ----
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
get_frame_base (frame),
get_frame_base (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)))
{
*************** sh64_frame_chain (struct frame_info *fra
*** 749,755 ****
if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
size = 4;
else
! size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode));
return read_memory_integer (get_frame_base (frame)
+ get_frame_extra_info (frame)->f_offset,
size);
--- 749,757 ----
if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
size = 4;
else
! size = register_size (current_gdbarch,
! translate_insn_rn (DEPRECATED_FP_REGNUM,
! media_mode));
return read_memory_integer (get_frame_base (frame)
+ get_frame_extra_info (frame)->f_offset,
size);
*************** sh64_get_saved_pr (struct frame_info *fi
*** 766,773 ****
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)))
! /* 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. */
return deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), pr_regnum);
else
--- 768,776 ----
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)))
! /* 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. */
return deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), pr_regnum);
else
*************** sh64_get_saved_pr (struct frame_info *fi
*** 783,796 ****
int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
? 4
! : DEPRECATED_REGISTER_RAW_SIZE (gdb_reg_num));
return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
}
}
return read_register (pr_regnum);
}
! /* For vectors of 4 floating point registers. */
static int
fv_reg_base_num (int fv_regnum)
{
--- 786,799 ----
int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
? 4
! : register_size (current_gdbarch, gdb_reg_num));
return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
}
}
return read_register (pr_regnum);
}
! /* For vectors of 4 floating point registers. */
static int
fv_reg_base_num (int fv_regnum)
{
*************** fpp_reg_base_num (int fpp_regnum)
*** 826,832 ****
static int
is_media_pseudo (int rn)
{
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
return (rn >= DR0_REGNUM
&& rn <= FV_LAST_REGNUM);
--- 829,835 ----
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
*** 842,848 ****
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)
--- 845,851 ----
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)
*************** static int
*** 925,931 ****
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
--- 928,934 ----
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
*************** sh64_compact_reg_base_num (int reg_nr)
*** 966,972 ****
base_regnum = 19;
else if (reg_nr == FPSCR_C_REGNUM)
! base_regnum = FPSCR_REGNUM; /*???? this register is a mess. */
else if (reg_nr == FPUL_C_REGNUM)
base_regnum = FP0_REGNUM + 32;
--- 969,975 ----
base_regnum = 19;
else if (reg_nr == FPSCR_C_REGNUM)
! base_regnum = FPSCR_REGNUM; /*???? this register is a mess. */
else if (reg_nr == FPUL_C_REGNUM)
base_regnum = FP0_REGNUM + 32;
*************** sh64_compact_reg_base_num (int reg_nr)
*** 977,983 ****
/* Given a register number RN (according to the gdb scheme) , return
its corresponding architectural register. In media mode, only a
subset of the registers is pseudo registers. For compact mode, all
! the registers are pseudo. */
static int
translate_rn_to_arch_reg_num (int rn, int media_mode)
{
--- 980,986 ----
/* Given a register number RN (according to the gdb scheme) , return
its corresponding architectural register. In media mode, only a
subset of the registers is pseudo registers. For compact mode, all
! the registers are pseudo. */
static int
translate_rn_to_arch_reg_num (int rn, int media_mode)
{
*************** translate_rn_to_arch_reg_num (int rn, in
*** 990,996 ****
return sh64_media_reg_base_num (rn);
}
else
! /* All compact registers are pseudo. */
return sh64_compact_reg_base_num (rn);
}
--- 993,999 ----
return sh64_media_reg_base_num (rn);
}
else
! /* All compact registers are pseudo. */
return sh64_compact_reg_base_num (rn);
}
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1021,1027 ****
int gdb_register_number;
int register_number;
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)
frame_saved_regs_zalloc (fi);
--- 1024,1030 ----
int gdb_register_number;
int register_number;
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)
frame_saved_regs_zalloc (fi);
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1047,1053 ****
/* Loop around examining the prologue insns until we find something
that does not appear to be part of the prologue. But give up
! after 20 of them, since we're getting silly then. */
pc = get_frame_func (fi);
if (!pc)
--- 1050,1056 ----
/* Loop around examining the prologue insns until we find something
that does not appear to be part of the prologue. But give up
! after 20 of them, since we're getting silly then. */
pc = get_frame_func (fi);
if (!pc)
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1069,1075 ****
/* The frame pointer register is general register 14 in shmedia and
shcompact modes. In sh compact it is a pseudo register. Same goes
! for the stack pointer register, which is register 15. */
fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode);
sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
--- 1072,1078 ----
/* The frame pointer register is general register 14 in shmedia and
shcompact modes. In sh compact it is a pseudo register. Same goes
! for the stack pointer register, which is register 15. */
fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode);
sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1108,1114 ****
else if (IS_ADD_SP_R0 (insn))
{
/* This instruction still prepares r0, but we don't care.
! We already have the offset in r0_val. */
}
else if (IS_STS_R0 (insn))
{
--- 1111,1117 ----
else if (IS_ADD_SP_R0 (insn))
{
/* This instruction still prepares r0, but we don't care.
! We already have the offset in r0_val. */
}
else if (IS_STS_R0 (insn))
{
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1169,1175 ****
}
}
! /* Now we know how deep things are, we can work out their addresses. */
for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
{
register_number = translate_rn_to_arch_reg_num (rn, media_mode);
--- 1172,1178 ----
}
}
! /* Now we know how deep things are, we can work out their addresses. */
for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
{
register_number = translate_rn_to_arch_reg_num (rn, media_mode);
*************** sh64_nofp_frame_init_saved_regs (struct
*** 1180,1213 ****
have_fp = 1;
/* Watch out! saved_regs is only for the real registers, and
! doesn't include space for the pseudo registers. */
! deprecated_get_frame_saved_regs (fi)[register_number]= get_frame_base (fi) - where[rn] + depth;
!
}
else
! deprecated_get_frame_saved_regs (fi)[register_number] = 0;
}
if (have_fp)
{
/* SP_REGNUM is 15. For shmedia 15 is the real register. For
shcompact 15 is the arch register corresponding to the pseudo
! register r15 which still is the SP register. */
/* The place on the stack where fp is stored contains the sp of
! the caller. */
/* Again, saved_registers contains only space for the real
registers, so we store in DEPRECATED_FP_REGNUM position. */
int size;
if (tdep->sh_abi == SH_ABI_32)
size = 4;
else
! size = DEPRECATED_REGISTER_RAW_SIZE (fp_regnum);
! deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size);
}
else
deprecated_get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
! get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum];
}
/* Initialize the extra info saved in a FRAME */
--- 1183,1218 ----
have_fp = 1;
/* Watch out! saved_regs is only for the real registers, and
! doesn't include space for the pseudo registers. */
! deprecated_get_frame_saved_regs (fi)[register_number]
! = get_frame_base (fi) - where[rn] + depth;
}
else
! deprecated_get_frame_saved_regs (fi)[register_number] = 0;
}
if (have_fp)
{
/* SP_REGNUM is 15. For shmedia 15 is the real register. For
shcompact 15 is the arch register corresponding to the pseudo
! register r15 which still is the SP register. */
/* The place on the stack where fp is stored contains the sp of
! the caller. */
/* Again, saved_registers contains only space for the real
registers, so we store in DEPRECATED_FP_REGNUM position. */
int size;
if (tdep->sh_abi == SH_ABI_32)
size = 4;
else
! size = register_size (current_gdbarch, fp_regnum);
! deprecated_get_frame_saved_regs (fi)[sp_regnum]
! = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum],
! size);
}
else
deprecated_get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
! get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum];
}
/* Initialize the extra info saved in a FRAME */
*************** sh64_get_saved_register (char *raw_buffe
*** 1249,1255 ****
{
int media_mode;
int live_regnum = regnum;
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (!target_has_registers)
error ("No registers.");
--- 1254,1260 ----
{
int media_mode;
int live_regnum = regnum;
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (!target_has_registers)
error ("No registers.");
*************** sh64_get_saved_register (char *raw_buffe
*** 1289,1295 ****
memcpy (raw_buffer,
(deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
+ DEPRECATED_REGISTER_BYTE (regnum)),
! DEPRECATED_REGISTER_RAW_SIZE (regnum));
return;
}
--- 1294,1300 ----
memcpy (raw_buffer,
(deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
+ DEPRECATED_REGISTER_BYTE (regnum)),
! register_size (current_gdbarch, regnum));
return;
}
*************** sh64_get_saved_register (char *raw_buffe
*** 1302,1308 ****
if (regnum == SP_REGNUM)
{
if (raw_buffer) /* SP register treated specially */
! store_unsigned_integer (raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum),
deprecated_get_frame_saved_regs (frame)[regnum]);
}
else
--- 1307,1315 ----
if (regnum == SP_REGNUM)
{
if (raw_buffer) /* SP register treated specially */
! store_unsigned_integer (raw_buffer,
! register_size (current_gdbarch,
! regnum),
deprecated_get_frame_saved_regs (frame)[regnum]);
}
else
*************** sh64_get_saved_register (char *raw_buffe
*** 1318,1330 ****
|| live_regnum == PR_REGNUM))
size = 4;
else
! size = DEPRECATED_REGISTER_RAW_SIZE (live_regnum);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
else
read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
raw_buffer
! + DEPRECATED_REGISTER_RAW_SIZE (live_regnum)
- size,
size);
}
--- 1325,1337 ----
|| live_regnum == PR_REGNUM))
size = 4;
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);
else
read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
raw_buffer
! + register_size (current_gdbarch, live_regnum)
- size,
size);
}
*************** static CORE_ADDR
*** 1348,1354 ****
sh64_extract_struct_value_address (char *regbuf)
{
return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
! DEPRECATED_REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
}
static CORE_ADDR
--- 1355,1362 ----
sh64_extract_struct_value_address (char *regbuf)
{
return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
! register_size (current_gdbarch,
! STRUCT_RETURN_REGNUM)));
}
static CORE_ADDR
*************** sh_frame_saved_pc (struct frame_info *fr
*** 1358,1371 ****
}
/* Discard from the stack the innermost frame, restoring all saved registers.
! Used in the 'return' command. */
static void
sh64_pop_frame (void)
{
struct frame_info *frame = get_current_frame ();
CORE_ADDR fp;
int regnum;
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int media_mode = pc_is_isa32 (get_frame_pc (frame));
--- 1366,1379 ----
}
/* Discard from the stack the innermost frame, restoring all saved registers.
! Used in the 'return' command. */
static void
sh64_pop_frame (void)
{
struct frame_info *frame = get_current_frame ();
CORE_ADDR fp;
int regnum;
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int media_mode = pc_is_isa32 (get_frame_pc (frame));
*************** sh64_pop_frame (void)
*** 1388,1395 ****
|| regnum == PR_REGNUM))
size = 4;
else
! size = DEPRECATED_REGISTER_RAW_SIZE (translate_insn_rn (regnum,
! media_mode));
write_register (regnum,
read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
size));
--- 1396,1403 ----
|| regnum == PR_REGNUM))
size = 4;
else
! size = register_size (current_gdbarch,
! translate_insn_rn (regnum, media_mode));
write_register (regnum,
read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
size));
*************** sh_frame_align (struct gdbarch *ignore,
*** 1467,1473 ****
I.e. there is hole in the stack.
Different rules apply for variable arguments functions, and for functions
! for which the prototype is not known. */
static CORE_ADDR
sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
--- 1475,1481 ----
I.e. there is hole in the stack.
Different rules apply for variable arguments functions, and for functions
! for which the prototype is not known. */
static CORE_ADDR
sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
*************** sh64_push_arguments (int nargs, struct v
*** 1488,1494 ****
int len;
int argreg_size;
int fp_args[12];
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
memset (fp_args, 0, sizeof (fp_args));
--- 1496,1502 ----
int len;
int argreg_size;
int fp_args[12];
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
memset (fp_args, 0, sizeof (fp_args));
*************** sh64_push_arguments (int nargs, struct v
*** 1522,1528 ****
if (TYPE_CODE (type) != TYPE_CODE_FLT)
{
! argreg_size = DEPRECATED_REGISTER_RAW_SIZE (int_argreg);
if (len < argreg_size)
{
--- 1530,1536 ----
if (TYPE_CODE (type) != TYPE_CODE_FLT)
{
! argreg_size = register_size (current_gdbarch, int_argreg);
if (len < argreg_size)
{
*************** sh64_push_arguments (int nargs, struct v
*** 1558,1564 ****
/* Store the value 8 bytes at a time. This means that
things larger than 8 bytes may go partly in registers
and partly on the stack. FIXME: argreg is incremented
! before we use its size. */
len -= argreg_size;
val += argreg_size;
int_argreg++;
--- 1566,1572 ----
/* Store the value 8 bytes at a time. This means that
things larger than 8 bytes may go partly in registers
and partly on the stack. FIXME: argreg is incremented
! before we use its size. */
len -= argreg_size;
val += argreg_size;
int_argreg++;
*************** sh64_push_arguments (int nargs, struct v
*** 1582,1594 ****
deprecated_write_register_gen (FP0_REGNUM + float_arg_index,
val);
fp_args[float_arg_index] = 1;
! /* Skip the corresponding general argument register. */
int_argreg ++;
}
else
;
/* Store it as the integers, 8 bytes at the time, if
! necessary spilling on the stack. */
}
else if (len == 8)
--- 1590,1602 ----
deprecated_write_register_gen (FP0_REGNUM + float_arg_index,
val);
fp_args[float_arg_index] = 1;
! /* Skip the corresponding general argument register. */
int_argreg ++;
}
else
;
/* Store it as the integers, 8 bytes at the time, if
! necessary spilling on the stack. */
}
else if (len == 8)
*************** sh64_push_arguments (int nargs, struct v
*** 1603,1609 ****
{
/* Goes in DR0...DR10 */
/* The numbering of the DRi registers is consecutive,
! i.e. includes odd numbers. */
int double_register_offset = double_arg_index / 2;
int regnum = DR0_REGNUM +
double_register_offset;
--- 1611,1617 ----
{
/* Goes in DR0...DR10 */
/* The numbering of the DRi registers is consecutive,
! i.e. includes odd numbers. */
int double_register_offset = double_arg_index / 2;
int regnum = DR0_REGNUM +
double_register_offset;
*************** sh64_push_arguments (int nargs, struct v
*** 1623,1639 ****
registers, not pseudo. write_register_gen will
call the gdbarch function to do register
writes, and that will properly know how to deal
! with pseudoregs. */
deprecated_write_register_gen (regnum, val);
fp_args[double_arg_index] = 1;
fp_args[double_arg_index + 1] = 1;
! /* Skip the corresponding general argument register. */
int_argreg ++;
}
else
;
/* Store it as the integers, 8 bytes at the time, if
! necessary spilling on the stack. */
}
}
}
--- 1631,1647 ----
registers, not pseudo. write_register_gen will
call the gdbarch function to do register
writes, and that will properly know how to deal
! with pseudoregs. */
deprecated_write_register_gen (regnum, val);
fp_args[double_arg_index] = 1;
fp_args[double_arg_index + 1] = 1;
! /* Skip the corresponding general argument register. */
int_argreg ++;
}
else
;
/* Store it as the integers, 8 bytes at the time, if
! necessary spilling on the stack. */
}
}
}
*************** sh64_extract_return_value (struct type *
*** 1661,1667 ****
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)
{
--- 1669,1675 ----
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_extract_return_value (struct type *
*** 1670,1676 ****
/* Return value stored in FP0_REGNUM */
return_register = FP0_REGNUM;
offset = DEPRECATED_REGISTER_BYTE (return_register);
! memcpy (valbuf, (char *) regbuf + offset, len);
}
else if (len == 8)
{
--- 1678,1684 ----
/* Return value stored in FP0_REGNUM */
return_register = FP0_REGNUM;
offset = DEPRECATED_REGISTER_BYTE (return_register);
! memcpy (valbuf, (char *) regbuf + offset, len);
}
else if (len == 8)
{
*************** sh64_extract_return_value (struct type *
*** 1686,1692 ****
else
floatformat_to_doublest (&floatformat_ieee_double_big,
(char *) regbuf + offset, &val);
! deprecated_store_floating (valbuf, len, val);
}
}
else
--- 1694,1700 ----
else
floatformat_to_doublest (&floatformat_ieee_double_big,
(char *) regbuf + offset, &val);
! store_typed_floating (valbuf, type, val);
}
}
else
*************** sh64_extract_return_value (struct type *
*** 1694,1704 ****
if (len <= 8)
{
/* Result is in register 2. If smaller than 8 bytes, it is padded
! at the most significant end. */
return_register = DEFAULT_RETURN_REGNUM;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = DEPRECATED_REGISTER_BYTE (return_register) +
! DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
else
offset = DEPRECATED_REGISTER_BYTE (return_register);
memcpy (valbuf, (char *) regbuf + offset, len);
--- 1702,1712 ----
if (len <= 8)
{
/* Result is in register 2. If smaller than 8 bytes, it is padded
! at the most significant end. */
return_register = DEFAULT_RETURN_REGNUM;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = DEPRECATED_REGISTER_BYTE (return_register) +
! register_size (current_gdbarch, return_register) - len;
else
offset = DEPRECATED_REGISTER_BYTE (return_register);
memcpy (valbuf, (char *) regbuf + offset, len);
*************** sh64_extract_return_value (struct type *
*** 1713,1724 ****
If the architecture is sh4 or sh3e, store a function's return value
in the R0 general register or in the FP0 floating point register,
depending on the type of the return value. In all the other cases
! the result is stored in r0, left-justified. */
static void
sh64_store_return_value (struct type *type, char *valbuf)
{
! char buf[64]; /* more than enough... */
int len = TYPE_LENGTH (type);
if (TYPE_CODE (type) == TYPE_CODE_FLT)
--- 1721,1732 ----
If the architecture is sh4 or sh3e, store a function's return value
in the R0 general register or in the FP0 floating point register,
depending on the type of the return value. In all the other cases
! the result is stored in r0, left-justified. */
static void
sh64_store_return_value (struct type *type, char *valbuf)
{
! char buf[64]; /* more than enough... */
int len = TYPE_LENGTH (type);
if (TYPE_CODE (type) == TYPE_CODE_FLT)
*************** sh64_store_return_value (struct type *ty
*** 1739,1752 ****
int return_register = DEFAULT_RETURN_REGNUM;
int offset = 0;
! if (len <= DEPRECATED_REGISTER_RAW_SIZE (return_register))
{
! /* Pad with zeros. */
! memset (buf, 0, DEPRECATED_REGISTER_RAW_SIZE (return_register));
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
! offset = 0; /*DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;*/
else
! offset = DEPRECATED_REGISTER_RAW_SIZE (return_register) - len;
memcpy (buf + offset, valbuf, len);
deprecated_write_register_gen (return_register, buf);
--- 1747,1761 ----
int return_register = DEFAULT_RETURN_REGNUM;
int offset = 0;
! if (len <= register_size (current_gdbarch, return_register))
{
! /* Pad with zeros. */
! memset (buf, 0, register_size (current_gdbarch, return_register));
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
! offset = 0; /*register_size (current_gdbarch,
! return_register) - len;*/
else
! offset = register_size (current_gdbarch, return_register) - len;
memcpy (buf + offset, valbuf, len);
deprecated_write_register_gen (return_register, buf);
*************** static void
*** 1760,1766 ****
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)),
--- 1769,1775 ----
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)),
*************** static void
*** 1799,1805 ****
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)));
--- 1808,1814 ----
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)));
*************** sh64_show_compact_regs (void)
*** 1837,1844 ****
(long) read_register (FP0_REGNUM + i + 7));
}
! /*FIXME!!! This only shows the registers for shmedia, excluding the
! pseudo registers. */
void
sh64_show_regs (void)
{
--- 1846,1853 ----
(long) read_register (FP0_REGNUM + i + 7));
}
! /* FIXME!!! This only shows the registers for shmedia, excluding the
! pseudo registers. */
void
sh64_show_regs (void)
{
*************** static int
*** 1921,1930 ****
sh_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. */
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
base_regnum = dr_reg_base_num (reg_nr);
--- 1930,1939 ----
sh_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. */
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
base_regnum = dr_reg_base_num (reg_nr);
*************** sh_sh64_register_byte (int reg_nr)
*** 1938,1951 ****
base_regnum = fv_reg_base_num (reg_nr);
/* sh compact pseudo register. FPSCR is a pathological case, need to
! treat it as special. */
else if ((reg_nr >= R0_C_REGNUM
&& reg_nr <= FV_LAST_C_REGNUM)
&& reg_nr != FPSCR_C_REGNUM)
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Now return the offset in bytes within the register cache. */
! /* sh media pseudo register, i.e. any of DR, FFP, FV registers. */
if (reg_nr >= DR0_REGNUM
&& reg_nr <= FV_LAST_REGNUM)
return (base_regnum - FP0_REGNUM + 1) * 4
--- 1947,1960 ----
base_regnum = fv_reg_base_num (reg_nr);
/* sh compact pseudo register. FPSCR is a pathological case, need to
! treat it as special. */
else if ((reg_nr >= R0_C_REGNUM
&& reg_nr <= FV_LAST_C_REGNUM)
&& reg_nr != FPSCR_C_REGNUM)
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Now return the offset in bytes within the register cache. */
! /* sh media pseudo register, i.e. any of DR, FFP, FV registers. */
if (reg_nr >= DR0_REGNUM
&& reg_nr <= FV_LAST_REGNUM)
return (base_regnum - FP0_REGNUM + 1) * 4
*************** sh_sh64_register_byte (int reg_nr)
*** 1981,1999 ****
else if (reg_nr == FPSCR_C_REGNUM)
/* This is complicated, for now return the beginning of the
! architectural FPSCR register. */
return (TR7_REGNUM + 1) * 8;
else if (reg_nr == FPUL_C_REGNUM)
return ((base_regnum - FP0_REGNUM) * 4 +
(TR7_REGNUM + 1) * 8 + 4);
! /* It is not a pseudo register. */
! /* It is a 64 bit register. */
else if (reg_nr <= TR7_REGNUM)
return reg_nr * 8;
! /* It is a 32 bit register. */
else if (reg_nr == FPSCR_REGNUM)
return (FPSCR_REGNUM * 8);
--- 1990,2008 ----
else if (reg_nr == FPSCR_C_REGNUM)
/* This is complicated, for now return the beginning of the
! architectural FPSCR register. */
return (TR7_REGNUM + 1) * 8;
else if (reg_nr == FPUL_C_REGNUM)
return ((base_regnum - FP0_REGNUM) * 4 +
(TR7_REGNUM + 1) * 8 + 4);
! /* It is not a pseudo register. */
! /* It is a 64 bit register. */
else if (reg_nr <= TR7_REGNUM)
return reg_nr * 8;
! /* It is a 32 bit register. */
else if (reg_nr == FPSCR_REGNUM)
return (FPSCR_REGNUM * 8);
*************** sh_sh64_register_byte (int reg_nr)
*** 2003,2043 ****
+ (reg_nr - FP0_REGNUM + 1) * 4);
}
- static int
- sh_sh64_register_raw_size (int reg_nr)
- {
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
- if ((reg_nr >= DR0_REGNUM
- && reg_nr <= DR_LAST_REGNUM)
- || (reg_nr >= FPP0_REGNUM
- && reg_nr <= FPP_LAST_REGNUM)
- || (reg_nr >= DR0_C_REGNUM
- && reg_nr <= DR_LAST_C_REGNUM)
- || (reg_nr <= TR7_REGNUM))
- return 8;
-
- else if ((reg_nr >= FV0_REGNUM
- && reg_nr <= FV_LAST_REGNUM)
- || (reg_nr >= FV0_C_REGNUM
- && reg_nr <= FV_LAST_C_REGNUM))
- return 16;
-
- else /* this covers also the 32-bit SH compact registers. */
- return 4;
- }
-
- /* ??????? FIXME */
- static int
- sh_sh64_register_virtual_size (int reg_nr)
- {
- if (reg_nr >= FP0_REGNUM
- && reg_nr <= FP_LAST_REGNUM)
- return 4;
- else
- return 8;
- }
-
static struct type *
sh_sh64_build_float_register_type (int high)
{
--- 2012,2017 ----
*************** sh_sh64_build_float_register_type (int h
*** 2047,2056 ****
return create_array_type (NULL, builtin_type_float, temp);
}
static struct type *
! sh_sh64_register_virtual_type (int reg_nr)
{
! struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if ((reg_nr >= FP0_REGNUM
&& reg_nr <= FP_LAST_REGNUM)
--- 2021,2032 ----
return create_array_type (NULL, builtin_type_float, temp);
}
+ /* Return the GDB type object for the "standard" data type
+ of data in register REG_NR. */
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)
*************** static void
*** 2083,2094 ****
sh_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. */
! memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
return;
}
--- 2059,2070 ----
sh_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. */
! memcpy (to, from, register_size (current_gdbarch, regnum));
return;
}
*************** sh_sh64_register_convert_to_virtual (int
*** 2098,2120 ****
&& regnum <= DR_LAST_C_REGNUM))
{
DOUBLEST val;
! floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
! deprecated_store_floating(to, TYPE_LENGTH(type), val);
}
else
! error("sh_register_convert_to_virtual called with non DR register number");
}
static void
sh_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. */
! memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regnum));
return;
}
--- 2074,2097 ----
&& regnum <= DR_LAST_C_REGNUM))
{
DOUBLEST val;
! floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
! from, &val);
! store_typed_floating(to, type, val);
}
else
! 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,
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. */
! memcpy (to, from, register_size (current_gdbarch, regnum));
return;
}
*************** sh_sh64_register_convert_to_raw (struct
*** 2124,2133 ****
&& regnum <= DR_LAST_C_REGNUM))
{
DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
! floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
}
else
! error("sh_register_convert_to_raw called with non DR register number");
}
static void
--- 2101,2111 ----
&& regnum <= DR_LAST_C_REGNUM))
{
DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
! floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
! &val, to);
}
else
! error("sh64_register_convert_to_raw called with non DR register number");
}
static void
*************** sh64_pseudo_register_read (struct gdbarc
*** 2138,2160 ****
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)
{
base_regnum = dr_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* DR regs are double precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
! /* We must pay attention to the endiannes. */
! sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr),
temp_buffer, buffer);
}
--- 2116,2140 ----
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)
{
base_regnum = dr_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* DR regs are double precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
(temp_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_pseudo_register_read (struct gdbarc
*** 2164,2176 ****
{
base_regnum = fpp_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FPP regs are pairs of single precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= FV0_REGNUM
--- 2144,2156 ----
{
base_regnum = fpp_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FPP regs are pairs of single precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch, base_regnum) * portion));
}
else if (reg_nr >= FV0_REGNUM
*************** sh64_pseudo_register_read (struct gdbarc
*** 2178,2190 ****
{
base_regnum = fv_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FV regs are vectors of single precision registers obtained by
! concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
/* sh compact pseudo registers. 1-to-1 with a shmedia register */
--- 2158,2170 ----
{
base_regnum = fv_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FV regs are vectors of single precision registers obtained by
! concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch, base_regnum) * portion));
}
/* sh compact pseudo registers. 1-to-1 with a shmedia register */
*************** sh64_pseudo_register_read (struct gdbarc
*** 2193,2199 ****
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
regcache_raw_read (regcache, base_regnum, temp_buffer);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = 4;
--- 2173,2179 ----
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
regcache_raw_read (regcache, base_regnum, temp_buffer);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = 4;
*************** sh64_pseudo_register_read (struct gdbarc
*** 2205,2213 ****
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* Floating point registers map 1-1 to the media fp regs,
! they have the same size and endienness. */
regcache_raw_read (regcache, base_regnum, buffer);
}
--- 2185,2193 ----
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* Floating point registers map 1-1 to the media fp regs,
! they have the same size and endianness. */
regcache_raw_read (regcache, base_regnum, buffer);
}
*************** sh64_pseudo_register_read (struct gdbarc
*** 2217,2230 ****
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* DR_C regs are double precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
(temp_buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
! /* We must pay attention to the endiannes. */
! sh_sh64_register_convert_to_virtual (reg_nr, DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr),
temp_buffer, buffer);
}
--- 2197,2212 ----
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* DR_C regs are double precision registers obtained by
! concatenating 2 single precision floating point registers. */
for (portion = 0; portion < 2; portion++)
regcache_raw_read (regcache, base_regnum + portion,
(temp_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_pseudo_register_read (struct gdbarc
*** 2233,2245 ****
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FV_C regs are vectors of single precision registers obtained by
! concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr == FPSCR_C_REGNUM)
--- 2215,2227 ----
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* Build the value in the provided buffer. */
/* FV_C regs are vectors of single precision registers obtained by
! concatenating 4 single precision floating point registers. */
for (portion = 0; portion < 4; portion++)
regcache_raw_read (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch, base_regnum) * portion));
}
else if (reg_nr == FPSCR_C_REGNUM)
*************** sh64_pseudo_register_read (struct gdbarc
*** 2255,2261 ****
fpscr_base_regnum = FPSCR_REGNUM;
sr_base_regnum = SR_REGNUM;
! /* Build the value in the provided buffer. */
/* FPSCR_C is a very weird register that contains sparse bits
from the FPSCR and the SR architectural registers.
Specifically: */
--- 2237,2243 ----
fpscr_base_regnum = FPSCR_REGNUM;
sr_base_regnum = SR_REGNUM;
! /* Build the value in the provided buffer. */
/* FPSCR_C is a very weird register that contains sparse bits
from the FPSCR and the SR architectural registers.
Specifically: */
*************** sh64_pseudo_register_read (struct gdbarc
*** 2271,2289 ****
/* *INDENT-ON* */
/* Get FPSCR into a local buffer */
regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
! /* Get value as an int. */
fpscr_value = extract_unsigned_integer (temp_buffer, 4);
/* Get SR into a local buffer */
regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
! /* Get value as an int. */
sr_value = extract_unsigned_integer (temp_buffer, 4);
! /* Build the new value. */
fpscr_c_part1_value = fpscr_value & 0x3fffd;
fpscr_c_part2_value = (sr_value & 0x7000) << 6;
fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
/* Store that in out buffer!!! */
store_unsigned_integer (buffer, 4, fpscr_c_value);
! /* FIXME There is surely an endianness gotcha here. */
}
else if (reg_nr == FPUL_C_REGNUM)
--- 2253,2271 ----
/* *INDENT-ON* */
/* Get FPSCR into a local buffer */
regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
! /* Get value as an int. */
fpscr_value = extract_unsigned_integer (temp_buffer, 4);
/* Get SR into a local buffer */
regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
! /* Get value as an int. */
sr_value = extract_unsigned_integer (temp_buffer, 4);
! /* Build the new value. */
fpscr_c_part1_value = fpscr_value & 0x3fffd;
fpscr_c_part2_value = (sr_value & 0x7000) << 6;
fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
/* Store that in out buffer!!! */
store_unsigned_integer (buffer, 4, fpscr_c_value);
! /* FIXME There is surely an endianness gotcha here. */
}
else if (reg_nr == FPUL_C_REGNUM)
*************** sh64_pseudo_register_read (struct gdbarc
*** 2291,2297 ****
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* FPUL_C register is floating point register 32,
! same size, same endianness. */
regcache_raw_read (regcache, base_regnum, buffer);
}
}
--- 2273,2279 ----
base_regnum = sh64_compact_reg_base_num (reg_nr);
/* FPUL_C register is floating point register 32,
! same size, same endianness. */
regcache_raw_read (regcache, base_regnum, buffer);
}
}
*************** sh64_pseudo_register_write (struct gdbar
*** 2309,2316 ****
&& reg_nr <= DR_LAST_REGNUM)
{
base_regnum = dr_reg_base_num (reg_nr);
! /* We must pay attention to the endiannes. */
! sh_sh64_register_convert_to_raw (DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
buffer, temp_buffer);
--- 2291,2299 ----
&& 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_pseudo_register_write (struct gdbar
*** 2318,2324 ****
for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= FPP0_REGNUM
--- 2301,2308 ----
for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
! + register_size (gdbarch,
! base_regnum) * portion));
}
else if (reg_nr >= FPP0_REGNUM
*************** sh64_pseudo_register_write (struct gdbar
*** 2330,2336 ****
for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
else if (reg_nr >= FV0_REGNUM
--- 2314,2321 ----
for (portion = 0; portion < 2; portion++)
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch,
! base_regnum) * portion));
}
else if (reg_nr >= FV0_REGNUM
*************** sh64_pseudo_register_write (struct gdbar
*** 2342,2348 ****
for (portion = 0; portion < 4; portion++)
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
/* sh compact general pseudo registers. 1-to-1 with a shmedia
--- 2327,2334 ----
for (portion = 0; portion < 4; portion++)
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch,
! base_regnum) * portion));
}
/* sh compact general pseudo registers. 1-to-1 with a shmedia
*************** sh64_pseudo_register_write (struct gdbar
*** 2351,2364 ****
&& reg_nr <= T_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* reg_nr is 32 bit here, and base_regnum is 64 bits. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = 4;
else
offset = 0;
/* Let's read the value of the base register into a temporary
buffer, so that overwriting the last four bytes with the new
! value of the pseudo will leave the upper 4 bytes unchanged. */
regcache_raw_read (regcache, base_regnum, temp_buffer);
/* Write as an 8 byte quantity */
memcpy (temp_buffer + offset, buffer, 4);
--- 2337,2350 ----
&& reg_nr <= T_C_REGNUM)
{
base_regnum = sh64_compact_reg_base_num (reg_nr);
! /* reg_nr is 32 bit here, and base_regnum is 64 bits. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
offset = 4;
else
offset = 0;
/* Let's read the value of the base register into a temporary
buffer, so that overwriting the last four bytes with the new
! value of the pseudo will leave the upper 4 bytes unchanged. */
regcache_raw_read (regcache, base_regnum, temp_buffer);
/* Write as an 8 byte quantity */
memcpy (temp_buffer + offset, buffer, 4);
*************** sh64_pseudo_register_write (struct gdbar
*** 2366,2372 ****
}
/* sh floating point compact pseudo registers. 1-to-1 with a shmedia
! registers. Both are 4 bytes. */
else if (reg_nr >= FP0_C_REGNUM
&& reg_nr <= FP_LAST_C_REGNUM)
{
--- 2352,2358 ----
}
/* sh floating point compact pseudo registers. 1-to-1 with a shmedia
! registers. Both are 4 bytes. */
else if (reg_nr >= FP0_C_REGNUM
&& reg_nr <= FP_LAST_C_REGNUM)
{
*************** sh64_pseudo_register_write (struct gdbar
*** 2380,2392 ****
base_regnum = sh64_compact_reg_base_num (reg_nr);
for (portion = 0; portion < 2; portion++)
{
! /* We must pay attention to the endiannes. */
! sh_sh64_register_convert_to_raw (DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
buffer, temp_buffer);
regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
--- 2366,2381 ----
base_regnum = sh64_compact_reg_base_num (reg_nr);
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);
regcache_raw_write (regcache, base_regnum + portion,
(temp_buffer
! + register_size (gdbarch,
! base_regnum) * portion));
}
}
*************** sh64_pseudo_register_write (struct gdbar
*** 2399,2405 ****
{
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + DEPRECATED_REGISTER_RAW_SIZE (base_regnum) * portion));
}
}
--- 2388,2395 ----
{
regcache_raw_write (regcache, base_regnum + portion,
((char *) buffer
! + register_size (gdbarch,
! base_regnum) * portion));
}
}
*************** sh64_pseudo_register_write (struct gdbar
*** 2431,2440 ****
21-31 reserved
*/
/* *INDENT-ON* */
! /* Get value as an int. */
fpscr_c_value = extract_unsigned_integer (buffer, 4);
! /* Build the new values. */
fpscr_mask = 0x0003fffd;
sr_mask = 0x001c0000;
--- 2421,2430 ----
21-31 reserved
*/
/* *INDENT-ON* */
! /* Get value as an int. */
fpscr_c_value = extract_unsigned_integer (buffer, 4);
! /* Build the new values. */
fpscr_mask = 0x0003fffd;
sr_mask = 0x001c0000;
*************** sh64_pseudo_register_write (struct gdbar
*** 2463,2469 ****
}
}
! /* Floating point vector of 4 float registers. */
static void
do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
int fv_regnum)
--- 2453,2459 ----
}
}
! /* Floating point vector of 4 float registers. */
static void
do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
int fv_regnum)
*************** do_fv_register_info (struct gdbarch *gdb
*** 2477,2483 ****
(int) read_register (first_fp_reg_num + 3));
}
! /* Floating point vector of 4 float registers, compact mode. */
static void
do_fv_c_register_info (int fv_regnum)
{
--- 2467,2473 ----
(int) read_register (first_fp_reg_num + 3));
}
! /* Floating point vector of 4 float registers, compact mode. */
static void
do_fv_c_register_info (int fv_regnum)
{
*************** do_fv_c_register_info (int fv_regnum)
*** 2491,2497 ****
}
/* Pairs of single regs. The DR are instead double precision
! registers. */
static void
do_fpp_register_info (int fpp_regnum)
{
--- 2481,2487 ----
}
/* Pairs of single regs. The DR are instead double precision
! registers. */
static void
do_fpp_register_info (int fpp_regnum)
{
*************** do_fpp_register_info (int fpp_regnum)
*** 2503,2509 ****
(int) read_register (first_fp_reg_num + 1));
}
! /* Double precision registers. */
static void
do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
int dr_regnum)
--- 2493,2499 ----
(int) read_register (first_fp_reg_num + 1));
}
! /* Double precision registers. */
static void
do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
int dr_regnum)
*************** do_dr_register_info (struct gdbarch *gdb
*** 2516,2522 ****
(int) read_register (first_fp_reg_num + 1));
}
! /* Double precision registers, compact mode. */
static void
do_dr_c_register_info (int dr_regnum)
{
--- 2506,2512 ----
(int) read_register (first_fp_reg_num + 1));
}
! /* Double precision registers, compact mode. */
static void
do_dr_c_register_info (int dr_regnum)
{
*************** do_dr_c_register_info (int dr_regnum)
*** 2528,2534 ****
(int) read_register (first_fp_reg_num +1));
}
! /* General register in compact mode. */
static void
do_r_c_register_info (int r_c_regnum)
{
--- 2518,2524 ----
(int) read_register (first_fp_reg_num +1));
}
! /* General register in compact mode. */
static void
do_r_c_register_info (int r_c_regnum)
{
*************** do_r_c_register_info (int r_c_regnum)
*** 2540,2547 ****
}
/* FIXME:!! THIS SHOULD TAKE CARE OF GETTING THE RIGHT PORTION OF THE
! shmedia REGISTERS. */
! /* Control registers, compact mode. */
static void
do_cr_c_register_info (int cr_c_regnum)
{
--- 2530,2537 ----
}
/* FIXME:!! THIS SHOULD TAKE CARE OF GETTING THE RIGHT PORTION OF THE
! shmedia REGISTERS. */
! /* Control registers, compact mode. */
static void
do_cr_c_register_info (int cr_c_regnum)
{
*************** sh_do_fp_register (struct gdbarch *gdbar
*** 2574,2580 ****
int inv;
int j;
! /* Allocate space for the float. */
raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
/* Get the data in raw format. */
--- 2564,2570 ----
int inv;
int j;
! /* Allocate space for the float. */
raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
/* Get the data in raw format. */
*************** sh_do_fp_register (struct gdbarch *gdbar
*** 2584,2600 ****
/* Get the register as a number */
flt = unpack_double (builtin_type_float, raw_buffer, &inv);
! /* Print the name and some spaces. */
fputs_filtered (REGISTER_NAME (regnum), file);
print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
! /* Print the value. */
if (inv)
fprintf_filtered (file, "<invalid float>");
else
fprintf_filtered (file, "%-10.9g", flt);
! /* Print the fp register as hex. */
fprintf_filtered (file, "\t(raw 0x");
for (j = 0; j < register_size (gdbarch, regnum); j++)
{
--- 2574,2590 ----
/* Get the register as a number */
flt = unpack_double (builtin_type_float, raw_buffer, &inv);
! /* Print the name and some spaces. */
fputs_filtered (REGISTER_NAME (regnum), file);
print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
! /* Print the value. */
if (inv)
fprintf_filtered (file, "<invalid float>");
else
fprintf_filtered (file, "%-10.9g", flt);
! /* Print the fp register as hex. */
fprintf_filtered (file, "\t(raw 0x");
for (j = 0; j < register_size (gdbarch, regnum); j++)
{
*************** sh_do_fp_register (struct gdbarch *gdbar
*** 2609,2616 ****
static void
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)
--- 2599,2606 ----
static void
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)
*************** sh64_do_pseudo_register (int regnum)
*** 2639,2654 ****
else if (regnum >= R0_C_REGNUM
&& regnum <= R_LAST_C_REGNUM)
! do_r_c_register_info (regnum); /* FIXME, this function will not print the right format */
!
else if (regnum >= FP0_C_REGNUM
&& regnum <= FP_LAST_C_REGNUM)
! sh_do_fp_register (current_gdbarch, gdb_stdout, regnum); /* this should work also for pseudoregs */
!
else if (regnum >= PC_C_REGNUM
&& regnum <= FPUL_C_REGNUM)
do_cr_c_register_info (regnum);
-
}
static void
--- 2629,2643 ----
else if (regnum >= R0_C_REGNUM
&& regnum <= R_LAST_C_REGNUM)
! /* FIXME, this function will not print the right format. */
! do_r_c_register_info (regnum);
else if (regnum >= FP0_C_REGNUM
&& regnum <= FP_LAST_C_REGNUM)
! /* This should work also for pseudoregs. */
! sh_do_fp_register (current_gdbarch, gdb_stdout, regnum);
else if (regnum >= PC_C_REGNUM
&& regnum <= FPUL_C_REGNUM)
do_cr_c_register_info (regnum);
}
static void
*************** sh_print_registers_info (struct gdbarch
*** 2746,2752 ****
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')
--- 2735,2741 ----
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')
*************** sh64_do_registers_info (int regnum, int
*** 2776,2782 ****
sh_print_registers_info (current_gdbarch, gdb_stdout,
deprecated_selected_frame, regnum, fpregs);
else
! sh_compact_do_registers_info (regnum, fpregs);
}
#ifdef SVR4_SHARED_LIBS
--- 2765,2771 ----
sh_print_registers_info (current_gdbarch, gdb_stdout,
deprecated_selected_frame, regnum, fpregs);
else
! sh_compact_do_registers_info (regnum, fpregs);
}
#ifdef SVR4_SHARED_LIBS
*************** sh64_gdbarch_init (struct gdbarch_info i
*** 2838,2844 ****
return arches->gdbarch;
/* None found, create a new architecture from the information
! provided. */
tdep = XMALLOC (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
--- 2827,2833 ----
return arches->gdbarch;
/* None found, create a new architecture from the information
! provided. */
tdep = XMALLOC (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
*************** sh64_gdbarch_init (struct gdbarch_info i
*** 2849,2855 ****
/* Determine the ABI */
if (info.abfd && bfd_get_arch_size (info.abfd) == 64)
{
! /* If the ABI is the 64-bit one, it can only be sh-media. */
tdep->sh_abi = SH_ABI_64;
set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
--- 2838,2844 ----
/* Determine the ABI */
if (info.abfd && bfd_get_arch_size (info.abfd) == 64)
{
! /* If the ABI is the 64-bit one, it can only be sh-media. */
tdep->sh_abi = SH_ABI_64;
set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
*************** sh64_gdbarch_init (struct gdbarch_info i
*** 2857,2863 ****
else
{
/* If the ABI is the 32-bit one it could be either media or
! compact. */
tdep->sh_abi = SH_ABI_32;
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
--- 2846,2852 ----
else
{
/* If the ABI is the 32-bit one it could be either media or
! compact. */
tdep->sh_abi = SH_ABI_32;
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
*************** sh64_gdbarch_init (struct gdbarch_info i
*** 2895,2921 ****
set_gdbarch_fp0_regnum (gdbarch, SIM_SH64_FR0_REGNUM);
set_gdbarch_pc_regnum (gdbarch, 64);
! /* 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_size (gdbarch, 8); /*????*/
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_deprecated_register_virtual_type (gdbarch, sh_sh64_register_virtual_type);
set_gdbarch_deprecated_store_return_value (gdbarch, sh64_store_return_value);
- set_gdbarch_deprecated_register_raw_size (gdbarch, sh_sh64_register_raw_size);
- set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_sh64_register_raw_size);
set_gdbarch_deprecated_register_byte (gdbarch, sh_sh64_register_byte);
- /* This seems awfully wrong!*/
- /*set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);*/
- /* should include the size of the pseudo regs. */
- set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4 * 4);
- /* Or should that go in the virtual_size? */
- /*set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);*/
- set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4 * 4);
set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
--- 2884,2900 ----
set_gdbarch_fp0_regnum (gdbarch, SIM_SH64_FR0_REGNUM);
set_gdbarch_pc_regnum (gdbarch, 64);
! /* 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_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_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);