X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsh-tdep.c;h=655aaaa0367154676387bc9f46321fb32cb0a95e;hb=c8a86edf1af0792db276785e5b3b22eba39dcdba;hp=d67636651ed181ff9520d07f9bbe74844d6f3708;hpb=1e2330ba1fbf486c2851272e2aa09dd57ad367e6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c index d67636651e..655aaaa036 100644 --- a/gdb/sh-tdep.c +++ b/gdb/sh-tdep.c @@ -33,7 +33,7 @@ #include "gdbcore.h" #include "value.h" #include "dis-asm.h" -#include "inferior.h" /* for BEFORE_TEXT_END etc. */ +#include "inferior.h" #include "gdb_string.h" #include "arch-utils.h" #include "floatformat.h" @@ -156,6 +156,28 @@ sh_sh3e_register_name (int reg_nr) return register_names[reg_nr]; } +static const char * +sh_sh2e_register_name (int reg_nr) +{ + static char *register_names[] = + { + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", + "pc", "pr", "gbr", "vbr", "mach", "macl", "sr", + "fpul", "fpscr", + "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", + "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15", + "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + }; + if (reg_nr < 0) + return NULL; + if (reg_nr >= (sizeof (register_names) / sizeof (*register_names))) + return NULL; + return register_names[reg_nr]; +} + static const char * sh_sh_dsp_register_name (int reg_nr) { @@ -340,7 +362,7 @@ sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) #define MSYMBOL_IS_SPECIAL(msym) \ (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0) -void +static void sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) { if (msym == NULL) @@ -921,8 +943,8 @@ gdb_print_insn_sh (bfd_vma memaddr, disassemble_info *info) /* Given a GDB frame, determine the address of the calling function's frame. This will be used to create a new GDB frame struct, and - then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be - called for the new frame. + then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC + will be called for the new frame. For us, the frame address is its stack pointer value, so we look up the function prologue to determine the caller's sp value, and return it. */ @@ -934,7 +956,8 @@ sh_frame_chain (struct frame_info *frame) get_frame_base (frame))) return get_frame_base (frame); /* dummy frame same as caller's frame */ if (get_frame_pc (frame) && !inside_entry_file (get_frame_pc (frame))) - return read_memory_integer (get_frame_base (frame) + frame->extra_info->f_offset, 4); + return read_memory_integer (get_frame_base (frame) + + get_frame_extra_info (frame)->f_offset, 4); else return 0; } @@ -980,8 +1003,10 @@ sh64_frame_chain (struct frame_info *frame) if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32) size = 4; else - size = REGISTER_RAW_SIZE (translate_insn_rn (FP_REGNUM, media_mode)); - return read_memory_integer (get_frame_base (frame) + frame->extra_info->f_offset, size); + size = 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); } else return 0; @@ -995,7 +1020,7 @@ sh64_frame_chain (struct frame_info *frame) static CORE_ADDR sh_find_callers_reg (struct frame_info *fi, int regnum) { - for (; fi; fi = fi->next) + 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 @@ -1004,7 +1029,7 @@ sh_find_callers_reg (struct frame_info *fi, int regnum) get_frame_base (fi), regnum); else { - FRAME_INIT_SAVED_REGS (fi); + DEPRECATED_FRAME_INIT_SAVED_REGS (fi); if (!get_frame_pc (fi)) return 0; if (get_frame_saved_regs (fi)[regnum] != 0) @@ -1019,7 +1044,7 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum) { int media_mode = 0; - for (; fi; fi = fi->next) + 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 @@ -1028,7 +1053,7 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum) get_frame_base (fi), pr_regnum); else { - FRAME_INIT_SAVED_REGS (fi); + DEPRECATED_FRAME_INIT_SAVED_REGS (fi); if (!get_frame_pc (fi)) return 0; @@ -1075,12 +1100,12 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi) /* DANGER! This is ONLY going to work if the char buffer format of the saved registers is byte-for-byte identical to the CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */ - memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs)); + memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS); return; } - fi->extra_info->leaf_function = 1; - fi->extra_info->f_offset = 0; + get_frame_extra_info (fi)->leaf_function = 1; + get_frame_extra_info (fi)->f_offset = 0; for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++) where[rn] = -1; @@ -1091,7 +1116,7 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi) 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_pc_function_start (get_frame_pc (fi)); + pc = get_frame_func (fi); if (!pc) { deprecated_update_frame_pc_hack (fi, 0); @@ -1112,7 +1137,7 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi) { where[gdbarch_tdep (current_gdbarch)->PR_REGNUM] = depth; /* If we're storing the pr then this isn't a leaf */ - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; depth += 4; } else if (IS_MOV_R3 (insn)) @@ -1147,7 +1172,7 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi) { if (where[rn] >= 0) { - if (rn == FP_REGNUM) + if (rn == DEPRECATED_FP_REGNUM) have_fp = 1; get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4; @@ -1160,14 +1185,14 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi) if (have_fp) { - get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4); + get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4); } else { get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4; } - fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4; + get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4; /* Work out the return pc - either from the saved pr or the pr value */ } @@ -1214,7 +1239,7 @@ is_media_pseudo (int rn) && rn <= tdep->FV_LAST_REGNUM); } -int +static int sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc) { return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc)); @@ -1415,12 +1440,12 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) /* DANGER! This is ONLY going to work if the char buffer format of the saved registers is byte-for-byte identical to the CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */ - memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs)); + memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS); return; } - fi->extra_info->leaf_function = 1; - fi->extra_info->f_offset = 0; + get_frame_extra_info (fi)->leaf_function = 1; + get_frame_extra_info (fi)->f_offset = 0; for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++) where[rn] = -1; @@ -1431,7 +1456,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) 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_pc_function_start (get_frame_pc (fi)); + pc = get_frame_func (fi); if (!pc) { deprecated_update_frame_pc_hack (fi, 0); @@ -1452,7 +1477,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) /* 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 (FP_REGNUM, media_mode); + fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode); sp_regnum = translate_insn_rn (SP_REGNUM, media_mode); for (opc = pc + (insn_size * 28); pc < opc; pc += insn_size) @@ -1470,7 +1495,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) int reg_nr = tdep->PR_C_REGNUM; where[reg_nr] = depth - ((((next_insn & 0xf) ^ 0x8) - 0x8) << 2); - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; pc += insn_size; } } @@ -1498,7 +1523,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) int reg_nr = tdep->PR_C_REGNUM; where[reg_nr] = depth - (r0_val - 4); r0_val -= 4; - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; } else if (IS_MOV_R14_R0 (insn)) { @@ -1526,14 +1551,14 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) { where[tdep->PR_REGNUM] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 3); - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; } else if (IS_STL_R18_R15 (insn)) { where[tdep->PR_REGNUM] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 2); - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; } else if (IS_STQ_R14_R15 (insn)) @@ -1577,8 +1602,8 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) 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 FP_REGNUM position. */ + /* 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; @@ -1589,7 +1614,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi) else get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi); - fi->extra_info->f_offset = depth - where[fp_regnum]; + get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum]; } static void @@ -1616,12 +1641,12 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi) /* DANGER! This is ONLY going to work if the char buffer format of the saved registers is byte-for-byte identical to the CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */ - memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs)); + memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS); return; } - fi->extra_info->leaf_function = 1; - fi->extra_info->f_offset = 0; + get_frame_extra_info (fi)->leaf_function = 1; + get_frame_extra_info (fi)->f_offset = 0; for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++) where[rn] = -1; @@ -1632,7 +1657,7 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi) 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_pc_function_start (get_frame_pc (fi)); + pc = get_frame_func (fi); if (!pc) { deprecated_update_frame_pc_hack (fi, 0); @@ -1653,7 +1678,7 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi) { where[tdep->PR_REGNUM] = depth; /* If we're storing the pr then this isn't a leaf */ - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; depth += 4; } else if (IS_MOV_R3 (insn)) @@ -1699,7 +1724,7 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi) { if (where[rn] >= 0) { - if (rn == FP_REGNUM) + if (rn == DEPRECATED_FP_REGNUM) have_fp = 1; get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4; @@ -1713,14 +1738,14 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi) if (have_fp) { get_frame_saved_regs (fi)[SP_REGNUM] = - read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4); + read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4); } else { get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4; } - fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4; + get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4; /* Work out the return pc - either from the saved pr or the pr value */ } @@ -1732,27 +1757,27 @@ sh_init_extra_frame_info (int fromleaf, struct frame_info *fi) frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info)); - if (fi->next) - deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next)); + if (get_next_frame (fi)) + deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi))); if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi), get_frame_base (fi))) { - /* We need to setup fi->frame here because run_stack_dummy gets it wrong - by assuming it's always FP. */ + /* We need to setup fi->frame here because call_function_by_hand + gets it wrong by assuming it's always FP. */ deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM)); - fi->extra_info->return_pc = deprecated_read_register_dummy (get_frame_pc (fi), + get_frame_extra_info (fi)->return_pc = deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), PC_REGNUM); - fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4); - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4); + get_frame_extra_info (fi)->leaf_function = 0; return; } else { - FRAME_INIT_SAVED_REGS (fi); - fi->extra_info->return_pc = + DEPRECATED_FRAME_INIT_SAVED_REGS (fi); + get_frame_extra_info (fi)->return_pc = sh_find_callers_reg (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM); } } @@ -1764,31 +1789,31 @@ sh64_init_extra_frame_info (int fromleaf, struct frame_info *fi) frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info)); - if (fi->next) - deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next)); + if (get_next_frame (fi)) + deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi))); if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi), get_frame_base (fi))) { - /* We need to setup fi->frame here because run_stack_dummy gets it wrong - by assuming it's always FP. */ + /* We need to setup fi->frame here because call_function_by_hand + gets it wrong by assuming it's always FP. */ deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM)); - fi->extra_info->return_pc = + get_frame_extra_info (fi)->return_pc = deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), PC_REGNUM); - fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4); - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4); + get_frame_extra_info (fi)->leaf_function = 0; return; } else { - FRAME_INIT_SAVED_REGS (fi); - fi->extra_info->return_pc = + DEPRECATED_FRAME_INIT_SAVED_REGS (fi); + get_frame_extra_info (fi)->return_pc = sh64_get_saved_pr (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM); } } -void +static void sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval) @@ -1823,7 +1848,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, the current frame itself: otherwise, we would be getting the previous frame's registers which were saved by the current frame. */ - while (frame && ((frame = frame->next) != NULL)) + while (frame && ((frame = get_next_frame (frame)) != NULL)) { if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), get_frame_base (frame), @@ -1839,7 +1864,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, return; } - FRAME_INIT_SAVED_REGS (frame); + DEPRECATED_FRAME_INIT_SAVED_REGS (frame); if (get_frame_saved_regs (frame) != NULL && get_frame_saved_regs (frame)[regnum] != 0) { @@ -1848,8 +1873,8 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, if (regnum == SP_REGNUM) { if (raw_buffer) /* SP register treated specially */ - store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), - get_frame_saved_regs (frame)[regnum]); + store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), + get_frame_saved_regs (frame)[regnum]); } else { /* any other register */ @@ -1860,7 +1885,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, { int size; if (tdep->sh_abi == SH_ABI_32 - && (live_regnum == FP_REGNUM + && (live_regnum == DEPRECATED_FP_REGNUM || live_regnum == tdep->PR_REGNUM)) size = 4; else @@ -1896,20 +1921,20 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, static CORE_ADDR sh_extract_struct_value_address (char *regbuf) { - return (extract_address ((regbuf), REGISTER_RAW_SIZE (0))); + return (extract_unsigned_integer ((regbuf), REGISTER_RAW_SIZE (0))); } static CORE_ADDR sh64_extract_struct_value_address (char *regbuf) { - return (extract_address ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)), - REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM))); + return (extract_unsigned_integer ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)), + REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM))); } static CORE_ADDR sh_frame_saved_pc (struct frame_info *frame) { - return ((frame)->extra_info->return_pc); + return (get_frame_extra_info (frame)->return_pc); } /* Discard from the stack the innermost frame, @@ -1928,7 +1953,7 @@ sh_pop_frame (void) else { fp = get_frame_base (frame); - FRAME_INIT_SAVED_REGS (frame); + DEPRECATED_FRAME_INIT_SAVED_REGS (frame); /* Copy regs from where they were saved in the frame */ for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) @@ -1936,7 +1961,7 @@ sh_pop_frame (void) write_register (regnum, read_memory_integer (get_frame_saved_regs (frame)[regnum], 4)); - write_register (PC_REGNUM, frame->extra_info->return_pc); + write_register (PC_REGNUM, get_frame_extra_info (frame)->return_pc); write_register (SP_REGNUM, fp + 4); } flush_cached_frames (); @@ -1960,7 +1985,7 @@ sh64_pop_frame (void) else { fp = get_frame_base (frame); - FRAME_INIT_SAVED_REGS (frame); + DEPRECATED_FRAME_INIT_SAVED_REGS (frame); /* Copy regs from where they were saved in the frame */ for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) @@ -1968,7 +1993,7 @@ sh64_pop_frame (void) { int size; if (tdep->sh_abi == SH_ABI_32 - && (regnum == FP_REGNUM + && (regnum == DEPRECATED_FP_REGNUM || regnum == tdep->PR_REGNUM)) size = 4; else @@ -1979,7 +2004,7 @@ sh64_pop_frame (void) size)); } - write_register (PC_REGNUM, frame->extra_info->return_pc); + write_register (PC_REGNUM, get_frame_extra_info (frame)->return_pc); write_register (SP_REGNUM, fp + 8); } flush_cached_frames (); @@ -2098,7 +2123,7 @@ sh_push_arguments (int nargs, struct value **args, CORE_ADDR sp, if (argreg <= tdep->ARGLAST_REGNUM) { /* there's room in a register */ - regval = extract_address (val, REGISTER_RAW_SIZE (argreg)); + regval = extract_unsigned_integer (val, REGISTER_RAW_SIZE (argreg)); write_register (argreg++, regval); } /* Store the value 4 bytes at a time. This means that things @@ -2213,7 +2238,7 @@ sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp, if (int_argreg <= tdep->ARGLAST_REGNUM) { /* there's room in a register */ - regval = extract_address (val, argreg_size); + regval = extract_unsigned_integer (val, argreg_size); write_register (int_argreg, regval); } /* Store the value 8 bytes at a time. This means that @@ -2272,8 +2297,9 @@ sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp, if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) { memset (valbuf_tmp, 0, sizeof (valbuf_tmp)); - REGISTER_CONVERT_TO_VIRTUAL (regnum, - type, val, valbuf_tmp); + DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, + type, val, + valbuf_tmp); val = valbuf_tmp; } #endif @@ -2389,7 +2415,7 @@ sh3e_sh4_extract_return_value (struct type *type, char *regbuf, char *valbuf) floatformat_to_doublest (&floatformat_ieee_double_big, (char *) regbuf + REGISTER_BYTE (return_register), &val); - store_floating (valbuf, len, val); + deprecated_store_floating (valbuf, len, val); } else if (len <= 4) { @@ -2442,7 +2468,7 @@ sh64_extract_return_value (struct type *type, char *regbuf, char *valbuf) else floatformat_to_doublest (&floatformat_ieee_double_big, (char *) regbuf + offset, &val); - store_floating (valbuf, len, val); + deprecated_store_floating (valbuf, len, val); } } else @@ -2621,6 +2647,62 @@ sh3_show_regs (void) } +static void +sh2e_show_regs (void) +{ + printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n", + paddr (read_register (PC_REGNUM)), + (long) read_register (SR_REGNUM), + (long) read_register (PR_REGNUM), + (long) read_register (MACH_REGNUM), + (long) read_register (MACL_REGNUM)); + + printf_filtered ("GBR=%08lx VBR=%08lx", + (long) read_register (GBR_REGNUM), + (long) read_register (VBR_REGNUM)); + printf_filtered (" FPUL=%08lx FPSCR=%08lx", + (long) read_register (gdbarch_tdep (current_gdbarch)->FPUL_REGNUM), + (long) read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM)); + + printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", + (long) read_register (0), + (long) read_register (1), + (long) read_register (2), + (long) read_register (3), + (long) read_register (4), + (long) read_register (5), + (long) read_register (6), + (long) read_register (7)); + printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", + (long) read_register (8), + (long) read_register (9), + (long) read_register (10), + (long) read_register (11), + (long) read_register (12), + (long) read_register (13), + (long) read_register (14), + (long) read_register (15)); + + printf_filtered (("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), + (long) read_register (FP0_REGNUM + 0), + (long) read_register (FP0_REGNUM + 1), + (long) read_register (FP0_REGNUM + 2), + (long) read_register (FP0_REGNUM + 3), + (long) read_register (FP0_REGNUM + 4), + (long) read_register (FP0_REGNUM + 5), + (long) read_register (FP0_REGNUM + 6), + (long) read_register (FP0_REGNUM + 7)); + printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), + (long) read_register (FP0_REGNUM + 8), + (long) read_register (FP0_REGNUM + 9), + (long) read_register (FP0_REGNUM + 10), + (long) read_register (FP0_REGNUM + 11), + (long) read_register (FP0_REGNUM + 12), + (long) read_register (FP0_REGNUM + 13), + (long) read_register (FP0_REGNUM + 14), + (long) read_register (FP0_REGNUM + 15)); +} + static void sh3e_show_regs (void) { @@ -2954,7 +3036,8 @@ sh64_show_regs (void) sh64_show_compact_regs (); } -void sh_show_regs_command (char *args, int from_tty) +static void +sh_show_regs_command (char *args, int from_tty) { if (sh_show_regs) (*sh_show_regs)(); @@ -3322,13 +3405,13 @@ sh_sh4_register_convert_to_virtual (int regnum, struct type *type, { DOUBLEST val; floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val); - store_floating (to, TYPE_LENGTH (type), val); + deprecated_store_floating (to, TYPE_LENGTH (type), val); } else error ("sh_register_convert_to_virtual called with non DR register number"); } -void +static void sh_sh64_register_convert_to_virtual (int regnum, struct type *type, char *from, char *to) { @@ -3348,7 +3431,7 @@ sh_sh64_register_convert_to_virtual (int regnum, struct type *type, { DOUBLEST val; floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val); - store_floating(to, TYPE_LENGTH(type), val); + deprecated_store_floating(to, TYPE_LENGTH(type), val); } else error("sh_register_convert_to_virtual called with non DR register number"); @@ -3363,14 +3446,14 @@ sh_sh4_register_convert_to_raw (struct type *type, int regnum, if (regnum >= tdep->DR0_REGNUM && regnum <= tdep->DR_LAST_REGNUM) { - DOUBLEST val = extract_floating (from, TYPE_LENGTH(type)); + 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"); } -void +static void sh_sh64_register_convert_to_raw (struct type *type, int regnum, const void *from, void *to) { @@ -3388,19 +3471,19 @@ sh_sh64_register_convert_to_raw (struct type *type, int regnum, || (regnum >= tdep->DR0_C_REGNUM && regnum <= tdep->DR_LAST_C_REGNUM)) { - DOUBLEST val = extract_floating (from, TYPE_LENGTH(type)); + 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"); } -void +static void sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, void *buffer) { int base_regnum, portion; - char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE); + char temp_buffer[MAX_REGISTER_SIZE]; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (reg_nr >= tdep->DR0_REGNUM @@ -3439,7 +3522,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int base_regnum; int portion; int offset = 0; - char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE); + char temp_buffer[MAX_REGISTER_SIZE]; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (reg_nr >= tdep->DR0_REGNUM @@ -3598,12 +3681,12 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, } } -void +static void sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const void *buffer) { int base_regnum, portion; - char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE); + char temp_buffer[MAX_REGISTER_SIZE]; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (reg_nr >= tdep->DR0_REGNUM @@ -3634,13 +3717,13 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, } } -void +static void sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const void *buffer) { int base_regnum, portion; int offset; - char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE); + char temp_buffer[MAX_REGISTER_SIZE]; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (reg_nr >= tdep->DR0_REGNUM @@ -4006,7 +4089,7 @@ sh64_do_pseudo_register (int regnum) static void sh_do_register (int regnum) { - char raw_buffer[MAX_REGISTER_RAW_SIZE]; + char raw_buffer[MAX_REGISTER_SIZE]; fputs_filtered (REGISTER_NAME (regnum), gdb_stdout); print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout); @@ -4042,7 +4125,7 @@ sh_print_register (int regnum) do_pseudo_register (regnum); } -void +static void sh_do_registers_info (int regnum, int fpregs) { if (regnum != -1) /* do one specified register */ @@ -4094,7 +4177,7 @@ sh_do_registers_info (int regnum, int fpregs) } } -void +static void sh_compact_do_registers_info (int regnum, int fpregs) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -4120,7 +4203,7 @@ sh_compact_do_registers_info (int regnum, int fpregs) } } -void +static void sh64_do_registers_info (int regnum, int fpregs) { if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame))) @@ -4225,7 +4308,7 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) struct gdbarch_tdep *tdep; gdbarch_register_name_ftype *sh_register_name; gdbarch_deprecated_store_return_value_ftype *sh_store_return_value; - gdbarch_register_virtual_type_ftype *sh_register_virtual_type; + gdbarch_deprecated_register_virtual_type_ftype *sh_register_virtual_type; /* If there is already a candidate, use it. */ arches = gdbarch_list_lookup_by_info (arches, &info); @@ -4278,27 +4361,27 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_fp0_regnum (gdbarch, -1); set_gdbarch_num_pseudo_regs (gdbarch, 0); - set_gdbarch_max_register_raw_size (gdbarch, 4); - set_gdbarch_max_register_virtual_size (gdbarch, 4); + set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4); + set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4); set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_num_regs (gdbarch, SH_DEFAULT_NUM_REGS); set_gdbarch_sp_regnum (gdbarch, 15); - set_gdbarch_fp_regnum (gdbarch, 14); + set_gdbarch_deprecated_fp_regnum (gdbarch, 14); set_gdbarch_pc_regnum (gdbarch, 16); - set_gdbarch_register_size (gdbarch, 4); - set_gdbarch_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4); + set_gdbarch_deprecated_register_size (gdbarch, 4); + set_gdbarch_deprecated_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4); set_gdbarch_deprecated_do_registers_info (gdbarch, sh_do_registers_info); set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc); - set_gdbarch_frame_chain (gdbarch, sh_frame_chain); - set_gdbarch_get_saved_register (gdbarch, deprecated_generic_get_saved_register); - set_gdbarch_init_extra_frame_info (gdbarch, sh_init_extra_frame_info); + set_gdbarch_deprecated_frame_chain (gdbarch, sh_frame_chain); + set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register); + set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh_init_extra_frame_info); set_gdbarch_deprecated_extract_return_value (gdbarch, sh_extract_return_value); - set_gdbarch_push_arguments (gdbarch, sh_push_arguments); - set_gdbarch_store_struct_return (gdbarch, sh_store_struct_return); + set_gdbarch_deprecated_push_arguments (gdbarch, sh_push_arguments); + set_gdbarch_deprecated_store_struct_return (gdbarch, sh_store_struct_return); set_gdbarch_use_struct_convention (gdbarch, sh_use_struct_convention); set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh_extract_struct_value_address); - set_gdbarch_pop_frame (gdbarch, sh_pop_frame); + set_gdbarch_deprecated_pop_frame (gdbarch, sh_pop_frame); set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh); set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno); skip_prologue_hard_way = sh_skip_prologue_hard_way; @@ -4311,30 +4394,44 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh_generic_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); break; case bfd_mach_sh2: sh_register_name = sh_sh_register_name; sh_show_regs = sh_generic_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); break; + case bfd_mach_sh2e: + sh_register_name = sh_sh2e_register_name; + sh_show_regs = sh2e_show_regs; + sh_store_return_value = sh3e_sh4_store_return_value; + sh_register_virtual_type = sh_sh3e_register_virtual_type; + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_fp0_regnum (gdbarch, 25); + tdep->FPUL_REGNUM = 23; + tdep->FPSCR_REGNUM = 24; + tdep->FP_LAST_REGNUM = 40; + break; case bfd_mach_sh_dsp: sh_register_name = sh_sh_dsp_register_name; sh_show_regs = sh_dsp_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno); tdep->DSR_REGNUM = 24; tdep->A0G_REGNUM = 25; @@ -4356,10 +4453,10 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh3_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); tdep->SSR_REGNUM = 41; tdep->SPC_REGNUM = 42; break; @@ -4368,10 +4465,10 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh3e_show_regs; sh_store_return_value = sh3e_sh4_store_return_value; sh_register_virtual_type = sh_sh3e_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value); set_gdbarch_fp0_regnum (gdbarch, 25); tdep->FPUL_REGNUM = 23; @@ -4385,10 +4482,10 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh3_dsp_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); tdep->DSR_REGNUM = 24; tdep->A0G_REGNUM = 25; tdep->A0_REGNUM = 26; @@ -4411,15 +4508,15 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh4_show_regs; sh_store_return_value = sh3e_sh4_store_return_value; sh_register_virtual_type = sh_sh4_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs); set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value); set_gdbarch_fp0_regnum (gdbarch, 25); - set_gdbarch_register_raw_size (gdbarch, sh_sh4_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_sh4_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_sh4_register_byte); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_sh4_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_sh4_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_sh4_register_byte); set_gdbarch_num_pseudo_regs (gdbarch, 12); - set_gdbarch_max_register_raw_size (gdbarch, 4 * 4); - set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4); + set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4 * 4); + set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4 * 4); set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read); set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write); tdep->FPUL_REGNUM = 23; @@ -4491,10 +4588,10 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* 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_register_size (gdbarch, 8); /*????*/ - set_gdbarch_register_bytes (gdbarch, - ((SIM_SH64_NR_FP_REGS + 1) * 4) - + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8); + 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); sh_register_name = sh_sh64_register_name; sh_show_regs = sh64_show_regs; @@ -4502,31 +4599,31 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_store_return_value = sh64_store_return_value; skip_prologue_hard_way = sh64_skip_prologue_hard_way; do_pseudo_register = sh64_do_pseudo_register; - set_gdbarch_register_raw_size (gdbarch, sh_sh64_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_sh64_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_sh64_register_byte); + 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_max_register_raw_size (gdbarch, 8);*/ + /*set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);*/ /* should include the size of the pseudo regs. */ - set_gdbarch_max_register_raw_size (gdbarch, 4 * 4); + set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4 * 4); /* Or should that go in the virtual_size? */ - /*set_gdbarch_max_register_virtual_size (gdbarch, 8);*/ - set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4); + /*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); set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info); - set_gdbarch_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs); set_gdbarch_breakpoint_from_pc (gdbarch, sh_sh64_breakpoint_from_pc); - set_gdbarch_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info); - set_gdbarch_frame_chain (gdbarch, sh64_frame_chain); - set_gdbarch_get_saved_register (gdbarch, sh64_get_saved_register); + set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info); + set_gdbarch_deprecated_frame_chain (gdbarch, sh64_frame_chain); + set_gdbarch_deprecated_get_saved_register (gdbarch, sh64_get_saved_register); set_gdbarch_deprecated_extract_return_value (gdbarch, sh64_extract_return_value); - set_gdbarch_push_arguments (gdbarch, sh64_push_arguments); - /*set_gdbarch_store_struct_return (gdbarch, sh64_store_struct_return);*/ + set_gdbarch_deprecated_push_arguments (gdbarch, sh64_push_arguments); + /*set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return);*/ set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention); - set_gdbarch_pop_frame (gdbarch, sh64_pop_frame); + set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame); set_gdbarch_elf_make_msymbol_special (gdbarch, sh64_elf_make_msymbol_special); break; @@ -4535,21 +4632,18 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) sh_show_regs = sh_generic_show_regs; sh_store_return_value = sh_default_store_return_value; sh_register_virtual_type = sh_default_register_virtual_type; - set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); - set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size); - set_gdbarch_register_byte (gdbarch, sh_default_register_byte); + set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs); + set_gdbarch_deprecated_register_raw_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_virtual_size (gdbarch, sh_default_register_raw_size); + set_gdbarch_deprecated_register_byte (gdbarch, sh_default_register_byte); break; } - set_gdbarch_read_pc (gdbarch, generic_target_read_pc); set_gdbarch_write_pc (gdbarch, generic_target_write_pc); - set_gdbarch_read_fp (gdbarch, generic_target_read_fp); - set_gdbarch_read_sp (gdbarch, generic_target_read_sp); - set_gdbarch_write_sp (gdbarch, generic_target_write_sp); + set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp); set_gdbarch_register_name (gdbarch, sh_register_name); - set_gdbarch_register_virtual_type (gdbarch, sh_register_virtual_type); + set_gdbarch_deprecated_register_virtual_type (gdbarch, sh_register_virtual_type); set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT); @@ -4558,19 +4652,10 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); - set_gdbarch_call_dummy_length (gdbarch, 0); - set_gdbarch_call_dummy_address (gdbarch, entry_point_address); - set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); /*???*/ - set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0); - set_gdbarch_call_dummy_start_offset (gdbarch, 0); - set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words); - set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words)); - set_gdbarch_call_dummy_p (gdbarch, 1); - set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0); - set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy); + set_gdbarch_deprecated_call_dummy_words (gdbarch, sh_call_dummy_words); + set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words)); - set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame); - set_gdbarch_push_return_address (gdbarch, sh_push_return_address); + set_gdbarch_deprecated_push_return_address (gdbarch, sh_push_return_address); set_gdbarch_deprecated_store_return_value (gdbarch, sh_store_return_value); set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue); @@ -4580,9 +4665,8 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_frame_args_skip (gdbarch, 0); set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue); - set_gdbarch_frame_saved_pc (gdbarch, sh_frame_saved_pc); - set_gdbarch_saved_pc_after_call (gdbarch, sh_saved_pc_after_call); - set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown); + set_gdbarch_deprecated_frame_saved_pc (gdbarch, sh_frame_saved_pc); + set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sh_saved_pc_after_call); set_gdbarch_believe_pcc_promotion (gdbarch, 1); /* Hook in ABI-specific overrides, if they have been registered. */ @@ -4602,6 +4686,8 @@ sh_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) /* FIXME: dump the rest of gdbarch_tdep. */ } +extern initialize_file_ftype _initialize_sh_tdep; /* -Wmissing-prototypes */ + void _initialize_sh_tdep (void) {