2003-11-12 Michael Snyder * 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, ""); 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, ""); 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);