X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsh64-tdep.c;h=8a64f97eb77e166afcf15e1148d7d5193594e5f2;hb=abc72ce4c676be2f368fa0ace766ed29cd444020;hp=62b68259f20c9eab5ebd664788d83b532fc4bbf1;hpb=93d42b302eb91d758191675dcaf3bd90323b5224;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c index 62b68259f2..8a64f97eb7 100644 --- a/gdb/sh64-tdep.c +++ b/gdb/sh64-tdep.c @@ -1,13 +1,13 @@ /* Target-dependent code for Renesas Super-H, for GDB. Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, - 2003, 2004, 2005, 2007 Free Software Foundation, Inc. + 2003, 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,9 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ /* Contributed by Steve Chamberlain @@ -42,6 +40,7 @@ #include "arch-utils.h" #include "regcache.h" #include "osabi.h" +#include "valprint.h" #include "elf-bfd.h" @@ -49,6 +48,7 @@ #include "elf/sh.h" /* registers numbers shared with the simulator */ #include "gdb/sim-sh.h" +#include "language.h" /* Information that is dependent on the processor variant. */ enum sh_abi @@ -95,7 +95,7 @@ enum DR0_REGNUM = 141, DR_LAST_REGNUM = 172, /* FPP stands for Floating Point Pair, to avoid confusion with - GDB's FP0_REGNUM, which is the number of the first Floating + GDB's gdbarch_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, @@ -126,7 +126,7 @@ enum }; static const char * -sh64_register_name (int reg_nr) +sh64_register_name (struct gdbarch *gdbarch, int reg_nr) { static char *register_names[] = { @@ -206,14 +206,13 @@ sh64_register_name (int reg_nr) symbol that marks it as 32-bit function. The MSB of the minimal symbol's "info" field is used for this purpose. - ELF_MAKE_MSYMBOL_SPECIAL - tests whether an ELF symbol is "special", i.e. refers - to a 32-bit function, and sets a "special" bit in a + gdbarch_elf_make_msymbol_special tests whether an ELF symbol is "special", + i.e. refers to a 32-bit function, and sets a "special" bit in a minimal symbol to mark it as a 32-bit function MSYMBOL_IS_SPECIAL tests the "special" bit in a minimal symbol */ #define MSYMBOL_IS_SPECIAL(msym) \ - (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0) + MSYMBOL_TARGET_FLAG_1 (msym) static void sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) @@ -223,7 +222,7 @@ sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32) { - MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) | 0x80000000); + MSYMBOL_TARGET_FLAG_1 (msym) = 1; SYMBOL_VALUE_ADDRESS (msym) |= 1; } } @@ -255,7 +254,7 @@ pc_is_isa32 (bfd_vma memaddr) } static const unsigned char * -sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +sh64_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr) { /* The BRK instruction for shmedia is 01101111 11110101 11111111 11110000 @@ -267,7 +266,7 @@ sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) which translates in big endian mode to 0x0, 0x3b and in little endian mode to 0x3b, 0x0*/ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { if (pc_is_isa32 (*pcptr)) { @@ -482,8 +481,10 @@ after_prologue (CORE_ADDR pc) } static CORE_ADDR -look_for_args_moves (CORE_ADDR start_pc, int media_mode) +look_for_args_moves (struct gdbarch *gdbarch, + CORE_ADDR start_pc, int media_mode) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR here, end; int w; int insn_size = (media_mode ? 4 : 2); @@ -492,7 +493,8 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) { if (media_mode) { - w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size); + w = read_memory_integer (UNMAKE_ISA32_ADDR (here), + insn_size, byte_order); here += insn_size; if (IS_MEDIA_IND_ARG_MOV (w)) { @@ -501,7 +503,7 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) the SP has been saved, unfortunately. */ int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here), - insn_size); + insn_size, byte_order); here += insn_size; if (IS_MEDIA_MOV_TO_R14 (next_insn)) start_pc = here; @@ -516,7 +518,7 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) } else { - w = read_memory_integer (here, insn_size); + w = read_memory_integer (here, insn_size, byte_order); w = w & 0xffff; here += insn_size; if (IS_COMPACT_IND_ARG_MOV (w)) @@ -525,7 +527,8 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) 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); + int next_insn = 0xffff & read_memory_integer (here, insn_size, + byte_order); here += insn_size; if (IS_COMPACT_MOV_TO_R14 (next_insn)) start_pc = here; @@ -558,11 +561,13 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) /* This must be followed by a JSR @r0 instruction and by a NOP instruction. After these, the prologue is over! */ - int next_insn = 0xffff & read_memory_integer (here, insn_size); + int next_insn = 0xffff & read_memory_integer (here, insn_size, + byte_order); here += insn_size; if (IS_JSR_R0 (next_insn)) { - next_insn = 0xffff & read_memory_integer (here, insn_size); + next_insn = 0xffff & read_memory_integer (here, insn_size, + byte_order); here += insn_size; if (IS_NOP (next_insn)) @@ -578,8 +583,9 @@ look_for_args_moves (CORE_ADDR start_pc, int media_mode) } static CORE_ADDR -sh64_skip_prologue_hard_way (CORE_ADDR start_pc) +sh64_skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR start_pc) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR here, end; int updated_fp = 0; int insn_size = 4; @@ -599,7 +605,8 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc) if (media_mode) { - int w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size); + int w = read_memory_integer (UNMAKE_ISA32_ADDR (here), + insn_size, byte_order); here += insn_size; if (IS_STQ_R18_R14 (w) || IS_STQ_R18_R15 (w) || IS_STQ_R14_R15 (w) || IS_STL_R14_R15 (w) || IS_STL_R18_R15 (w) @@ -618,13 +625,14 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc) /* 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); + start_pc = look_for_args_moves (gdbarch, + here - insn_size, media_mode); break; } } else { - int w = 0xffff & read_memory_integer (here, insn_size); + int w = 0xffff & read_memory_integer (here, insn_size, byte_order); here += insn_size; if (IS_STS_R0 (w) || IS_STS_PR (w) @@ -644,7 +652,8 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc) /* 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); + start_pc = look_for_args_moves (gdbarch, + here - insn_size, media_mode); break; } } @@ -654,7 +663,7 @@ sh64_skip_prologue_hard_way (CORE_ADDR start_pc) } static CORE_ADDR -sh64_skip_prologue (CORE_ADDR pc) +sh64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { CORE_ADDR post_prologue_pc; @@ -668,7 +677,7 @@ sh64_skip_prologue (CORE_ADDR pc) if (post_prologue_pc != 0) return max (pc, post_prologue_pc); else - return sh64_skip_prologue_hard_way (pc); + return sh64_skip_prologue_hard_way (gdbarch, pc); } /* Should call_function allocate stack space for a struct return? */ @@ -678,44 +687,33 @@ sh64_use_struct_convention (struct type *type) return (TYPE_LENGTH (type) > 8); } -/* Disassemble an instruction. */ -static int -gdb_print_insn_sh64 (bfd_vma memaddr, disassemble_info *info) -{ - info->endian = TARGET_BYTE_ORDER; - return print_insn_sh (memaddr, info); -} - /* For vectors of 4 floating point registers. */ static int -sh64_fv_reg_base_num (int fv_regnum) +sh64_fv_reg_base_num (struct gdbarch *gdbarch, int fv_regnum) { int fp_regnum; - fp_regnum = FP0_REGNUM + - (fv_regnum - FV0_REGNUM) * 4; + fp_regnum = gdbarch_fp0_regnum (gdbarch) + (fv_regnum - FV0_REGNUM) * 4; return fp_regnum; } /* For double precision floating point registers, i.e 2 fp regs.*/ static int -sh64_dr_reg_base_num (int dr_regnum) +sh64_dr_reg_base_num (struct gdbarch *gdbarch, int dr_regnum) { int fp_regnum; - fp_regnum = FP0_REGNUM + - (dr_regnum - DR0_REGNUM) * 2; + fp_regnum = gdbarch_fp0_regnum (gdbarch) + (dr_regnum - DR0_REGNUM) * 2; return fp_regnum; } /* For pairs of floating point registers */ static int -sh64_fpp_reg_base_num (int fpp_regnum) +sh64_fpp_reg_base_num (struct gdbarch *gdbarch, int fpp_regnum) { int fp_regnum; - fp_regnum = FP0_REGNUM + - (fpp_regnum - FPP0_REGNUM) * 2; + fp_regnum = gdbarch_fp0_regnum (gdbarch) + (fpp_regnum - FPP0_REGNUM) * 2; return fp_regnum; } @@ -782,7 +780,7 @@ sh64_fpp_reg_base_num (int fpp_regnum) */ /* *INDENT-ON* */ static int -sh64_compact_reg_base_num (int reg_nr) +sh64_compact_reg_base_num (struct gdbarch *gdbarch, int reg_nr) { int base_regnum = reg_nr; @@ -794,20 +792,22 @@ sh64_compact_reg_base_num (int reg_nr) /* floating point register N maps to floating point register N */ else if (reg_nr >= FP0_C_REGNUM && reg_nr <= FP_LAST_C_REGNUM) - base_regnum = reg_nr - FP0_C_REGNUM + FP0_REGNUM; + base_regnum = reg_nr - FP0_C_REGNUM + gdbarch_fp0_regnum (gdbarch); /* double prec register N maps to base regnum for double prec register N */ else if (reg_nr >= DR0_C_REGNUM && reg_nr <= DR_LAST_C_REGNUM) - base_regnum = sh64_dr_reg_base_num (DR0_REGNUM + reg_nr - DR0_C_REGNUM); + base_regnum = sh64_dr_reg_base_num (gdbarch, + DR0_REGNUM + reg_nr - DR0_C_REGNUM); /* vector N maps to base regnum for vector register N */ else if (reg_nr >= FV0_C_REGNUM && reg_nr <= FV_LAST_C_REGNUM) - base_regnum = sh64_fv_reg_base_num (FV0_REGNUM + reg_nr - FV0_C_REGNUM); + base_regnum = sh64_fv_reg_base_num (gdbarch, + FV0_REGNUM + reg_nr - FV0_C_REGNUM); else if (reg_nr == PC_C_REGNUM) - base_regnum = PC_REGNUM; + base_regnum = gdbarch_pc_regnum (gdbarch); else if (reg_nr == GBR_C_REGNUM) base_regnum = 16; @@ -826,7 +826,7 @@ sh64_compact_reg_base_num (int reg_nr) base_regnum = FPSCR_REGNUM; /*???? this register is a mess. */ else if (reg_nr == FPUL_C_REGNUM) - base_regnum = FP0_REGNUM + 32; + base_regnum = gdbarch_fp0_regnum (gdbarch) + 32; return base_regnum; } @@ -855,6 +855,7 @@ sh64_analyze_prologue (struct gdbarch *gdbarch, int gdb_register_number; int register_number; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); cache->sp_offset = 0; @@ -876,13 +877,14 @@ sh64_analyze_prologue (struct gdbarch *gdbarch, { insn = read_memory_integer (cache->media_mode ? UNMAKE_ISA32_ADDR (pc) : pc, - insn_size); + insn_size, byte_order); if (!cache->media_mode) { if (IS_STS_PR (insn)) { - int next_insn = read_memory_integer (pc + insn_size, insn_size); + int next_insn = read_memory_integer (pc + insn_size, + insn_size, byte_order); if (IS_MOV_TO_R15 (next_insn)) { cache->saved_regs[PR_REGNUM] = @@ -962,17 +964,6 @@ sh64_analyze_prologue (struct gdbarch *gdbarch, cache->uses_fp = 1; } -static CORE_ADDR -sh64_extract_struct_value_address (struct regcache *regcache) -{ - /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return - address regster is preserved across function calls? Probably - not, making this function wrong. */ - ULONGEST val; - regcache_raw_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &val); - return val; -} - static CORE_ADDR sh64_frame_align (struct gdbarch *ignore, CORE_ADDR sp) { @@ -1050,6 +1041,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int stack_offset, stack_alloc; int int_argreg; int float_argreg; @@ -1088,7 +1080,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, in eight registers available. Loop thru args from first to last. */ int_argreg = ARG0_REGNUM; - float_argreg = FP0_REGNUM; + float_argreg = gdbarch_fp0_regnum (gdbarch); double_argreg = DR0_REGNUM; for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++) @@ -1099,12 +1091,12 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, if (TYPE_CODE (type) != TYPE_CODE_FLT) { - argreg_size = register_size (current_gdbarch, int_argreg); + argreg_size = register_size (gdbarch, int_argreg); if (len < argreg_size) { /* value gets right-justified in the register or stack word */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) memcpy (valbuf + argreg_size - len, (char *) value_contents (args[argnum]), len); else @@ -1130,7 +1122,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, if (int_argreg <= ARGLAST_REGNUM) { /* there's room in a register */ - regval = extract_unsigned_integer (val, argreg_size); + regval = extract_unsigned_integer (val, argreg_size, + byte_order); regcache_cooked_write_unsigned (regcache, int_argreg, regval); } /* Store the value 8 bytes at a time. This means that @@ -1158,7 +1151,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, { /* Goes in FR0...FR11 */ regcache_cooked_write (regcache, - FP0_REGNUM + float_arg_index, + gdbarch_fp0_regnum (gdbarch) + + float_arg_index, val); fp_args[float_arg_index] = 1; /* Skip the corresponding general argument register. */ @@ -1202,7 +1196,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch, regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr); /* Update stack pointer. */ - regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp); + regcache_cooked_write_unsigned (regcache, + gdbarch_sp_regnum (gdbarch), sp); return sp; } @@ -1215,14 +1210,17 @@ static void sh64_extract_return_value (struct type *type, struct regcache *regcache, void *valbuf) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int len = TYPE_LENGTH (type); - + if (TYPE_CODE (type) == TYPE_CODE_FLT) { if (len == 4) { - /* Return value stored in FP0_REGNUM */ - regcache_raw_read (regcache, FP0_REGNUM, valbuf); + /* Return value stored in gdbarch_fp0_regnum */ + regcache_raw_read (regcache, + gdbarch_fp0_regnum (gdbarch), valbuf); } else if (len == 8) { @@ -1232,7 +1230,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache, regcache_cooked_read (regcache, DR0_REGNUM, buf); - if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, buf, &val); else @@ -1251,8 +1249,8 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache, at the most significant end. */ regcache_raw_read (regcache, DEFAULT_RETURN_REGNUM, buf); - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) - offset = register_size (current_gdbarch, DEFAULT_RETURN_REGNUM) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) + offset = register_size (gdbarch, DEFAULT_RETURN_REGNUM) - len; else offset = 0; @@ -1274,14 +1272,15 @@ static void sh64_store_return_value (struct type *type, struct regcache *regcache, const void *valbuf) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); char buf[64]; /* more than enough... */ int len = TYPE_LENGTH (type); if (TYPE_CODE (type) == TYPE_CODE_FLT) { - int i, regnum = FP0_REGNUM; + int i, regnum = gdbarch_fp0_regnum (gdbarch); for (i = 0; i < len; i += 4) - if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) regcache_raw_write (regcache, regnum++, (char *) valbuf + len - 4 - i); else @@ -1292,15 +1291,15 @@ sh64_store_return_value (struct type *type, struct regcache *regcache, int return_register = DEFAULT_RETURN_REGNUM; int offset = 0; - if (len <= register_size (current_gdbarch, return_register)) + if (len <= register_size (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, + memset (buf, 0, register_size (gdbarch, return_register)); + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) + offset = 0; /*register_size (gdbarch, return_register) - len;*/ else - offset = register_size (current_gdbarch, return_register) - len; + offset = register_size (gdbarch, return_register) - len; memcpy (buf + offset, valbuf, len); regcache_raw_write (regcache, return_register, buf); @@ -1311,8 +1310,8 @@ sh64_store_return_value (struct type *type, struct regcache *regcache, } static enum return_value_convention -sh64_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, +sh64_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { if (sh64_use_struct_convention (type)) @@ -1325,93 +1324,122 @@ sh64_return_value (struct gdbarch *gdbarch, struct type *type, } static void -sh64_show_media_regs (void) +sh64_show_media_regs (struct frame_info *frame) { + struct gdbarch *gdbarch = get_frame_arch (frame); int i; - printf_filtered ("PC=%s SR=%016llx \n", - paddr (read_register (PC_REGNUM)), - (long long) read_register (SR_REGNUM)); + printf_filtered + ("PC=%s SR=%s\n", + phex (get_frame_register_unsigned (frame, + gdbarch_pc_regnum (gdbarch)), 8), + phex (get_frame_register_unsigned (frame, SR_REGNUM), 8)); - printf_filtered ("SSR=%016llx SPC=%016llx \n", - (long long) read_register (SSR_REGNUM), - (long long) read_register (SPC_REGNUM)); - printf_filtered ("FPSCR=%016lx\n ", - (long) read_register (FPSCR_REGNUM)); + printf_filtered + ("SSR=%s SPC=%s\n", + phex (get_frame_register_unsigned (frame, SSR_REGNUM), 8), + phex (get_frame_register_unsigned (frame, SPC_REGNUM), 8)); + printf_filtered + ("FPSCR=%s\n ", + phex (get_frame_register_unsigned (frame, FPSCR_REGNUM), 8)); for (i = 0; i < 64; i = i + 4) - printf_filtered ("\nR%d-R%d %016llx %016llx %016llx %016llx\n", - i, i + 3, - (long long) read_register (i + 0), - (long long) read_register (i + 1), - (long long) read_register (i + 2), - (long long) read_register (i + 3)); + printf_filtered + ("\nR%d-R%d %s %s %s %s\n", + i, i + 3, + phex (get_frame_register_unsigned (frame, i + 0), 8), + phex (get_frame_register_unsigned (frame, i + 1), 8), + phex (get_frame_register_unsigned (frame, i + 2), 8), + phex (get_frame_register_unsigned (frame, i + 3), 8)); printf_filtered ("\n"); for (i = 0; i < 64; i = i + 8) - printf_filtered ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", - i, i + 7, - (long) read_register (FP0_REGNUM + i + 0), - (long) read_register (FP0_REGNUM + i + 1), - (long) read_register (FP0_REGNUM + i + 2), - (long) read_register (FP0_REGNUM + i + 3), - (long) read_register (FP0_REGNUM + i + 4), - (long) read_register (FP0_REGNUM + i + 5), - (long) read_register (FP0_REGNUM + i + 6), - (long) read_register (FP0_REGNUM + i + 7)); + printf_filtered + ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", + i, i + 7, + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 0), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 1), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 2), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 3), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 4), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 5), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 6), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 7)); } static void -sh64_show_compact_regs (void) +sh64_show_compact_regs (struct frame_info *frame) { + struct gdbarch *gdbarch = get_frame_arch (frame); int i; - printf_filtered ("PC=%s \n", - paddr (read_register (PC_C_REGNUM))); - - printf_filtered ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n", - (long) read_register (GBR_C_REGNUM), - (long) read_register (MACH_C_REGNUM), - (long) read_register (MACL_C_REGNUM), - (long) read_register (PR_C_REGNUM), - (long) read_register (T_C_REGNUM)); - printf_filtered ("FPSCR=%08lx FPUL=%08lx\n", - (long) read_register (FPSCR_C_REGNUM), - (long) read_register (FPUL_C_REGNUM)); + printf_filtered + ("PC=%s\n", + phex (get_frame_register_unsigned (frame, PC_C_REGNUM), 8)); + + printf_filtered + ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n", + (long) get_frame_register_unsigned (frame, GBR_C_REGNUM), + (long) get_frame_register_unsigned (frame, MACH_C_REGNUM), + (long) get_frame_register_unsigned (frame, MACL_C_REGNUM), + (long) get_frame_register_unsigned (frame, PR_C_REGNUM), + (long) get_frame_register_unsigned (frame, T_C_REGNUM)); + printf_filtered + ("FPSCR=%08lx FPUL=%08lx\n", + (long) get_frame_register_unsigned (frame, FPSCR_C_REGNUM), + (long) get_frame_register_unsigned (frame, FPUL_C_REGNUM)); for (i = 0; i < 16; i = i + 4) - printf_filtered ("\nR%d-R%d %08lx %08lx %08lx %08lx\n", - i, i + 3, - (long) read_register (i + 0), - (long) read_register (i + 1), - (long) read_register (i + 2), - (long) read_register (i + 3)); + printf_filtered + ("\nR%d-R%d %08lx %08lx %08lx %08lx\n", + i, i + 3, + (long) get_frame_register_unsigned (frame, i + 0), + (long) get_frame_register_unsigned (frame, i + 1), + (long) get_frame_register_unsigned (frame, i + 2), + (long) get_frame_register_unsigned (frame, i + 3)); printf_filtered ("\n"); for (i = 0; i < 16; i = i + 8) - printf_filtered ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", - i, i + 7, - (long) read_register (FP0_REGNUM + i + 0), - (long) read_register (FP0_REGNUM + i + 1), - (long) read_register (FP0_REGNUM + i + 2), - (long) read_register (FP0_REGNUM + i + 3), - (long) read_register (FP0_REGNUM + i + 4), - (long) read_register (FP0_REGNUM + i + 5), - (long) read_register (FP0_REGNUM + i + 6), - (long) read_register (FP0_REGNUM + i + 7)); + printf_filtered + ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", + i, i + 7, + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 0), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 1), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 2), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 3), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 4), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 5), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 6), + (long) get_frame_register_unsigned + (frame, gdbarch_fp0_regnum (gdbarch) + i + 7)); } /* FIXME!!! This only shows the registers for shmedia, excluding the pseudo registers. */ void -sh64_show_regs (void) +sh64_show_regs (struct frame_info *frame) { - if (pc_is_isa32 (get_frame_pc (get_selected_frame (NULL)))) - sh64_show_media_regs (); + if (pc_is_isa32 (get_frame_pc (frame))) + sh64_show_media_regs (frame); else - sh64_show_compact_regs (); + sh64_show_compact_regs (frame); } /* *INDENT-OFF* */ @@ -1483,12 +1511,10 @@ REGISTER_BYTE returns the register byte for the base register. */ static struct type * -sh64_build_float_register_type (int high) +sh64_build_float_register_type (struct gdbarch *gdbarch, int high) { - struct type *temp; - - temp = create_range_type (NULL, builtin_type_int, 0, high); - return create_array_type (NULL, builtin_type_float, temp); + return lookup_array_range_type (builtin_type (gdbarch)->builtin_float, + 0, high); } /* Return the GDB type object for the "standard" data type @@ -1496,41 +1522,41 @@ sh64_build_float_register_type (int high) static struct type * sh64_register_type (struct gdbarch *gdbarch, int reg_nr) { - if ((reg_nr >= FP0_REGNUM + if ((reg_nr >= gdbarch_fp0_regnum (gdbarch) && reg_nr <= FP_LAST_REGNUM) || (reg_nr >= FP0_C_REGNUM && reg_nr <= FP_LAST_C_REGNUM)) - return builtin_type_float; + return builtin_type (gdbarch)->builtin_float; else if ((reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM) || (reg_nr >= DR0_C_REGNUM && reg_nr <= DR_LAST_C_REGNUM)) - return builtin_type_double; + return builtin_type (gdbarch)->builtin_double; else if (reg_nr >= FPP0_REGNUM && reg_nr <= FPP_LAST_REGNUM) - return sh64_build_float_register_type (1); + return sh64_build_float_register_type (gdbarch, 1); else if ((reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM) ||(reg_nr >= FV0_C_REGNUM && reg_nr <= FV_LAST_C_REGNUM)) - return sh64_build_float_register_type (3); + return sh64_build_float_register_type (gdbarch, 3); else if (reg_nr == FPSCR_REGNUM) - return builtin_type_int; + return builtin_type (gdbarch)->builtin_int; else if (reg_nr >= R0_C_REGNUM && reg_nr < FP0_C_REGNUM) - return builtin_type_int; + return builtin_type (gdbarch)->builtin_int; else - return builtin_type_long_long; + return builtin_type (gdbarch)->builtin_long_long; } static void -sh64_register_convert_to_virtual (int regnum, struct type *type, - char *from, char *to) +sh64_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, + struct type *type, char *from, char *to) { - if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE) + if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE) { /* It is a no-op. */ - memcpy (to, from, register_size (current_gdbarch, regnum)); + memcpy (to, from, register_size (gdbarch, regnum)); return; } @@ -1549,13 +1575,13 @@ sh64_register_convert_to_virtual (int regnum, struct type *type, } static void -sh64_register_convert_to_raw (struct type *type, int regnum, - const void *from, void *to) +sh64_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, + int regnum, const void *from, void *to) { - if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE) + if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE) { /* It is a no-op. */ - memcpy (to, from, register_size (current_gdbarch, regnum)); + memcpy (to, from, register_size (gdbarch, regnum)); return; } @@ -1564,7 +1590,7 @@ sh64_register_convert_to_raw (struct type *type, int regnum, || (regnum >= DR0_C_REGNUM && regnum <= DR_LAST_C_REGNUM)) { - DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type)); + DOUBLEST val = extract_typed_floating (from, type); floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to); } @@ -1576,6 +1602,7 @@ static void sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int base_regnum; int portion; int offset = 0; @@ -1584,7 +1611,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM) { - base_regnum = sh64_dr_reg_base_num (reg_nr); + base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ /* DR regs are double precision registers obtained by @@ -1595,7 +1622,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, + register_size (gdbarch, base_regnum) * portion)); /* We must pay attention to the endianness. */ - sh64_register_convert_to_virtual (reg_nr, + sh64_register_convert_to_virtual (gdbarch, reg_nr, register_type (gdbarch, reg_nr), temp_buffer, buffer); @@ -1604,7 +1631,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FPP0_REGNUM && reg_nr <= FPP_LAST_REGNUM) { - base_regnum = sh64_fpp_reg_base_num (reg_nr); + base_regnum = sh64_fpp_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ /* FPP regs are pairs of single precision registers obtained by @@ -1618,7 +1645,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM) { - base_regnum = sh64_fv_reg_base_num (reg_nr); + base_regnum = sh64_fv_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ /* FV regs are vectors of single precision registers obtained by @@ -1633,11 +1660,11 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= R0_C_REGNUM && reg_nr <= T_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ regcache_raw_read (regcache, base_regnum, temp_buffer); - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset = 4; memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/ } @@ -1645,7 +1672,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FP0_C_REGNUM && reg_nr <= FP_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ /* Floating point registers map 1-1 to the media fp regs, @@ -1656,7 +1683,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= DR0_C_REGNUM && reg_nr <= DR_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* DR_C regs are double precision registers obtained by concatenating 2 single precision floating point registers. */ @@ -1666,7 +1693,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, + register_size (gdbarch, base_regnum) * portion)); /* We must pay attention to the endianness. */ - sh64_register_convert_to_virtual (reg_nr, + sh64_register_convert_to_virtual (gdbarch, reg_nr, register_type (gdbarch, reg_nr), temp_buffer, buffer); } @@ -1674,7 +1701,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FV0_C_REGNUM && reg_nr <= FV_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* Build the value in the provided buffer. */ /* FV_C regs are vectors of single precision registers obtained by @@ -1715,23 +1742,23 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, /* 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); + fpscr_value = extract_unsigned_integer (temp_buffer, 4, byte_order); /* 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); + sr_value = extract_unsigned_integer (temp_buffer, 4, byte_order); /* 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); + store_unsigned_integer (buffer, 4, byte_order, fpscr_c_value); /* FIXME There is surely an endianness gotcha here. */ } else if (reg_nr == FPUL_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* FPUL_C register is floating point register 32, same size, same endianness. */ @@ -1743,6 +1770,7 @@ static void sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int base_regnum, portion; int offset; char temp_buffer[MAX_REGISTER_SIZE]; @@ -1750,9 +1778,9 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM) { - base_regnum = sh64_dr_reg_base_num (reg_nr); + base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr); /* We must pay attention to the endianness. */ - sh64_register_convert_to_raw (register_type (gdbarch, reg_nr), + sh64_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr), reg_nr, buffer, temp_buffer); @@ -1767,7 +1795,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FPP0_REGNUM && reg_nr <= FPP_LAST_REGNUM) { - base_regnum = sh64_fpp_reg_base_num (reg_nr); + base_regnum = sh64_fpp_reg_base_num (gdbarch, reg_nr); /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 2; portion++) @@ -1780,7 +1808,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM) { - base_regnum = sh64_fv_reg_base_num (reg_nr); + base_regnum = sh64_fv_reg_base_num (gdbarch, reg_nr); /* Write the real regs for which this one is an alias. */ for (portion = 0; portion < 4; portion++) @@ -1795,9 +1823,9 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= R0_C_REGNUM && reg_nr <= T_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); /* reg_nr is 32 bit here, and base_regnum is 64 bits. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset = 4; else offset = 0; @@ -1815,18 +1843,19 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FP0_C_REGNUM && reg_nr <= FP_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); regcache_raw_write (regcache, base_regnum, buffer); } else if (reg_nr >= DR0_C_REGNUM && reg_nr <= DR_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); for (portion = 0; portion < 2; portion++) { /* We must pay attention to the endianness. */ - sh64_register_convert_to_raw (register_type (gdbarch, reg_nr), + sh64_register_convert_to_raw (gdbarch, + register_type (gdbarch, reg_nr), reg_nr, buffer, temp_buffer); @@ -1840,7 +1869,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, else if (reg_nr >= FV0_C_REGNUM && reg_nr <= FV_LAST_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); for (portion = 0; portion < 4; portion++) { @@ -1880,7 +1909,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, */ /* *INDENT-ON* */ /* Get value as an int. */ - fpscr_c_value = extract_unsigned_integer (buffer, 4); + fpscr_c_value = extract_unsigned_integer (buffer, 4, byte_order); /* Build the new values. */ fpscr_mask = 0x0003fffd; @@ -1890,23 +1919,23 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, sr_value = (fpscr_value & sr_mask) >> 6; regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer); - old_fpscr_value = extract_unsigned_integer (temp_buffer, 4); + old_fpscr_value = extract_unsigned_integer (temp_buffer, 4, byte_order); old_fpscr_value &= 0xfffc0002; fpscr_value |= old_fpscr_value; - store_unsigned_integer (temp_buffer, 4, fpscr_value); + store_unsigned_integer (temp_buffer, 4, byte_order, fpscr_value); regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer); regcache_raw_read (regcache, sr_base_regnum, temp_buffer); - old_sr_value = extract_unsigned_integer (temp_buffer, 4); + old_sr_value = extract_unsigned_integer (temp_buffer, 4, byte_order); old_sr_value &= 0xffff8fff; sr_value |= old_sr_value; - store_unsigned_integer (temp_buffer, 4, sr_value); + store_unsigned_integer (temp_buffer, 4, byte_order, sr_value); regcache_raw_write (regcache, sr_base_regnum, temp_buffer); } else if (reg_nr == FPUL_C_REGNUM) { - base_regnum = sh64_compact_reg_base_num (reg_nr); + base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr); regcache_raw_write (regcache, base_regnum, buffer); } } @@ -1965,18 +1994,23 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, int j; /* Allocate space for the float. */ - raw_buffer = (unsigned char *) alloca (register_size (gdbarch, FP0_REGNUM)); + raw_buffer = (unsigned char *) alloca + (register_size (gdbarch, + gdbarch_fp0_regnum + (gdbarch))); /* Get the data in raw format. */ if (!frame_register_read (frame, regnum, raw_buffer)) - error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum)); + error ("can't read register %d (%s)", + regnum, gdbarch_register_name (gdbarch, regnum)); /* Get the register as a number */ - flt = unpack_double (builtin_type_float, raw_buffer, &inv); + flt = unpack_double (builtin_type (gdbarch)->builtin_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); + fputs_filtered (gdbarch_register_name (gdbarch, regnum), file); + print_spaces_filtered (15 - strlen (gdbarch_register_name + (gdbarch, regnum)), file); /* Print the value. */ if (inv) @@ -1988,8 +2022,9 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, fprintf_filtered (file, "\t(raw 0x"); for (j = 0; j < register_size (gdbarch, regnum); j++) { - int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j - : register_size (gdbarch, regnum) - 1 - j; + int idx = gdbarch_byte_order (gdbarch) + == BFD_ENDIAN_BIG ? j : register_size + (gdbarch, regnum) - 1 - j; fprintf_filtered (file, "%02x", raw_buffer[idx]); } fprintf_filtered (file, ")"); @@ -2002,15 +2037,16 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, { /* All the sh64-compact mode registers are pseudo registers. */ - if (regnum < NUM_REGS - || regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA - + NUM_PSEUDO_REGS_SH_COMPACT) + if (regnum < gdbarch_num_regs (gdbarch) + || regnum >= gdbarch_num_regs (gdbarch) + + NUM_PSEUDO_REGS_SH_MEDIA + + NUM_PSEUDO_REGS_SH_COMPACT) internal_error (__FILE__, __LINE__, _("Invalid pseudo register number %d\n"), regnum); else if ((regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)) { - int fp_regnum = sh64_dr_reg_base_num (regnum); + int fp_regnum = sh64_dr_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "dr%d\t0x%08x%08x\n", regnum - DR0_REGNUM, (unsigned) get_frame_register_unsigned (frame, fp_regnum), (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1)); @@ -2018,7 +2054,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, else if ((regnum >= DR0_C_REGNUM && regnum <= DR_LAST_C_REGNUM)) { - int fp_regnum = sh64_compact_reg_base_num (regnum); + int fp_regnum = sh64_compact_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "dr%d_c\t0x%08x%08x\n", regnum - DR0_C_REGNUM, (unsigned) get_frame_register_unsigned (frame, fp_regnum), (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1)); @@ -2026,7 +2062,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, else if ((regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM)) { - int fp_regnum = sh64_fv_reg_base_num (regnum); + int fp_regnum = sh64_fv_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", regnum - FV0_REGNUM, (unsigned) get_frame_register_unsigned (frame, fp_regnum), @@ -2037,7 +2073,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, else if ((regnum >= FV0_C_REGNUM && regnum <= FV_LAST_C_REGNUM)) { - int fp_regnum = sh64_compact_reg_base_num (regnum); + int fp_regnum = sh64_compact_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "fv%d_c\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n", regnum - FV0_C_REGNUM, (unsigned) get_frame_register_unsigned (frame, fp_regnum), @@ -2048,7 +2084,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, else if (regnum >= FPP0_REGNUM && regnum <= FPP_LAST_REGNUM) { - int fp_regnum = sh64_fpp_reg_base_num (regnum); + int fp_regnum = sh64_fpp_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "fpp%d\t0x%08x\t0x%08x\n", regnum - FPP0_REGNUM, (unsigned) get_frame_register_unsigned (frame, fp_regnum), (unsigned) get_frame_register_unsigned (frame, fp_regnum + 1)); @@ -2056,7 +2092,7 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file, else if (regnum >= R0_C_REGNUM && regnum <= R_LAST_C_REGNUM) { - int c_regnum = sh64_compact_reg_base_num (regnum); + int c_regnum = sh64_compact_reg_base_num (gdbarch, regnum); fprintf_filtered (file, "r%d_c\t0x%08x\n", regnum - R0_C_REGNUM, (unsigned) get_frame_register_unsigned (frame, c_regnum)); } @@ -2072,19 +2108,25 @@ sh64_do_register (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum) { unsigned char raw_buffer[MAX_REGISTER_SIZE]; + struct value_print_options opts; - fputs_filtered (REGISTER_NAME (regnum), file); - print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file); + fputs_filtered (gdbarch_register_name (gdbarch, regnum), file); + print_spaces_filtered (15 - strlen (gdbarch_register_name + (gdbarch, regnum)), file); /* Get the data in raw format. */ if (!frame_register_read (frame, regnum, raw_buffer)) fprintf_filtered (file, "*value not available*\n"); - + + get_formatted_print_options (&opts, 'x'); + opts.deref_ref = 1; val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0, - file, 'x', 1, 0, Val_pretty_default); + file, 0, NULL, &opts, current_language); fprintf_filtered (file, "\t"); + get_formatted_print_options (&opts, 0); + opts.deref_ref = 1; val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0, - file, 0, 1, 0, Val_pretty_default); + file, 0, NULL, &opts, current_language); fprintf_filtered (file, "\n"); } @@ -2092,11 +2134,12 @@ static void sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum) { - if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS) + if (regnum < 0 || regnum >= gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) internal_error (__FILE__, __LINE__, _("Invalid register number %d\n"), regnum); - else if (regnum >= 0 && regnum < NUM_REGS) + else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)) { if (TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT) sh64_do_fp_register (gdbarch, file, frame, regnum); /* FP regs */ @@ -2104,7 +2147,8 @@ sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file, sh64_do_register (gdbarch, file, frame, regnum); } - else if (regnum < NUM_REGS + NUM_PSEUDO_REGS) + else if (regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) sh64_do_pseudo_register (gdbarch, file, frame, regnum); } @@ -2115,7 +2159,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, { if (regnum != -1) /* do one specified register */ { - if (*(REGISTER_NAME (regnum)) == '\0') + if (*(gdbarch_register_name (gdbarch, regnum)) == '\0') error ("Not a valid register for the current processor type"); sh64_print_register (gdbarch, file, frame, regnum); @@ -2124,12 +2168,12 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, /* do all (or most) registers */ { regnum = 0; - while (regnum < NUM_REGS) + while (regnum < gdbarch_num_regs (gdbarch)) { /* If the register name is empty, it is undefined for this processor, so don't display anything. */ - if (REGISTER_NAME (regnum) == NULL - || *(REGISTER_NAME (regnum)) == '\0') + if (gdbarch_register_name (gdbarch, regnum) == NULL + || *(gdbarch_register_name (gdbarch, regnum)) == '\0') { regnum++; continue; @@ -2145,7 +2189,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, regnum ++; } else - regnum += FP_LAST_REGNUM - FP0_REGNUM; /* skip FP regs */ + regnum += FP_LAST_REGNUM - gdbarch_fp0_regnum (gdbarch); + /* skip FP regs */ } else { @@ -2155,7 +2200,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, } if (fpregs) - while (regnum < NUM_REGS + NUM_PSEUDO_REGS) + while (regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) { sh64_do_pseudo_register (gdbarch, file, frame, regnum); regnum++; @@ -2171,7 +2217,7 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch, { if (regnum != -1) /* do one specified register */ { - if (*(REGISTER_NAME (regnum)) == '\0') + if (*(gdbarch_register_name (gdbarch, regnum)) == '\0') error ("Not a valid register for the current processor type"); if (regnum >= 0 && regnum < R0_C_REGNUM) @@ -2183,7 +2229,8 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch, /* do all compact registers */ { regnum = R0_C_REGNUM; - while (regnum < NUM_REGS + NUM_PSEUDO_REGS) + while (regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) { sh64_do_pseudo_register (gdbarch, file, frame, regnum); regnum++; @@ -2229,8 +2276,9 @@ sh64_alloc_frame_cache (void) } static struct sh64_frame_cache * -sh64_frame_cache (struct frame_info *next_frame, void **this_cache) +sh64_frame_cache (struct frame_info *this_frame, void **this_cache) { + struct gdbarch *gdbarch; struct sh64_frame_cache *cache; CORE_ADDR current_pc; int i; @@ -2238,10 +2286,11 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache) if (*this_cache) return *this_cache; + gdbarch = get_frame_arch (this_frame); cache = sh64_alloc_frame_cache (); *this_cache = cache; - current_pc = frame_pc_unwind (next_frame); + current_pc = get_frame_pc (this_frame); cache->media_mode = pc_is_isa32 (current_pc); /* In principle, for normal frames, fp holds the frame pointer, @@ -2249,13 +2298,13 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache) However, for functions that don't need it, the frame pointer is optional. For these "frameless" functions the frame pointer is actually the frame pointer of the calling frame. */ - cache->base = frame_unwind_register_unsigned (next_frame, MEDIA_FP_REGNUM); + cache->base = get_frame_register_unsigned (this_frame, MEDIA_FP_REGNUM); if (cache->base == 0) return cache; - cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); + cache->pc = get_frame_func (this_frame); if (cache->pc != 0) - sh64_analyze_prologue (current_gdbarch, cache, cache->pc, current_pc); + sh64_analyze_prologue (gdbarch, cache, cache->pc, current_pc); if (!cache->uses_fp) { @@ -2266,7 +2315,8 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache) setup yet. Try to reconstruct the base address for the stack frame by looking at the stack pointer. For truly "frameless" functions this might work too. */ - cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); + cache->base = get_frame_register_unsigned + (this_frame, gdbarch_sp_regnum (gdbarch)); } /* Now that we have the base address for the stack frame we can @@ -2282,76 +2332,48 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache) return cache; } -static void -sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache, - int regnum, int *optimizedp, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, gdb_byte *valuep) +static struct value * +sh64_frame_prev_register (struct frame_info *this_frame, + void **this_cache, int regnum) { - struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache); + struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache); + struct gdbarch *gdbarch = get_frame_arch (this_frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_assert (regnum >= 0); - if (regnum == SP_REGNUM && cache->saved_sp) - { - *optimizedp = 0; - *lvalp = not_lval; - *addrp = 0; - *realnump = -1; - if (valuep) - { - /* Store the value. */ - store_unsigned_integer (valuep, - register_size (current_gdbarch, SP_REGNUM), - cache->saved_sp); - } - return; - } + if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp) + frame_unwind_got_constant (this_frame, regnum, cache->saved_sp); /* The PC of the previous frame is stored in the PR register of the current frame. Frob regnum so that we pull the value from the correct place. */ - if (regnum == PC_REGNUM) + if (regnum == gdbarch_pc_regnum (gdbarch)) regnum = PR_REGNUM; if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1) { - int reg_size = register_size (current_gdbarch, regnum); - int size; - - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = cache->saved_regs[regnum]; - *realnump = -1; - if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32 + if (gdbarch_tdep (gdbarch)->sh_abi == SH_ABI_32 && (regnum == MEDIA_FP_REGNUM || regnum == PR_REGNUM)) - size = 4; - else - size = reg_size; - if (valuep) { - memset (valuep, 0, reg_size); - if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) - read_memory (*addrp, valuep, size); - else - read_memory (*addrp, (char *) valuep + reg_size - size, size); + CORE_ADDR val; + val = read_memory_unsigned_integer (cache->saved_regs[regnum], + 4, byte_order); + return frame_unwind_got_constant (this_frame, regnum, val); } - return; + + return frame_unwind_got_memory (this_frame, regnum, + cache->saved_regs[regnum]); } - *optimizedp = 0; - *lvalp = lval_register; - *addrp = 0; - *realnump = regnum; - if (valuep) - frame_unwind_register (next_frame, (*realnump), valuep); + return frame_unwind_got_register (this_frame, regnum, regnum); } static void -sh64_frame_this_id (struct frame_info *next_frame, void **this_cache, +sh64_frame_this_id (struct frame_info *this_frame, void **this_cache, struct frame_id *this_id) { - struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache); + struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache); /* This marks the outermost frame. */ if (cache->base == 0) @@ -2363,38 +2385,37 @@ sh64_frame_this_id (struct frame_info *next_frame, void **this_cache, static const struct frame_unwind sh64_frame_unwind = { NORMAL_FRAME, sh64_frame_this_id, - sh64_frame_prev_register + sh64_frame_prev_register, + NULL, + default_frame_sniffer }; -static const struct frame_unwind * -sh64_frame_sniffer (struct frame_info *next_frame) -{ - return &sh64_frame_unwind; -} - static CORE_ADDR sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) { - return frame_unwind_register_unsigned (next_frame, SP_REGNUM); + return frame_unwind_register_unsigned (next_frame, + gdbarch_sp_regnum (gdbarch)); } static CORE_ADDR sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) { - return frame_unwind_register_unsigned (next_frame, PC_REGNUM); + return frame_unwind_register_unsigned (next_frame, + gdbarch_pc_regnum (gdbarch)); } static struct frame_id -sh64_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +sh64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { - return frame_id_build (sh64_unwind_sp (gdbarch, next_frame), - frame_pc_unwind (next_frame)); + CORE_ADDR sp = get_frame_register_unsigned (this_frame, + gdbarch_sp_regnum (gdbarch)); + return frame_id_build (sp, get_frame_pc (this_frame)); } static CORE_ADDR -sh64_frame_base_address (struct frame_info *next_frame, void **this_cache) +sh64_frame_base_address (struct frame_info *this_frame, void **this_cache) { - struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache); + struct sh64_frame_cache *cache = sh64_frame_cache (this_frame, this_cache); return cache->base; } @@ -2465,14 +2486,10 @@ sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc); - set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh64); + set_gdbarch_print_insn (gdbarch, print_insn_sh); set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno); - set_gdbarch_write_pc (gdbarch, generic_target_write_pc); - set_gdbarch_return_value (gdbarch, sh64_return_value); - set_gdbarch_deprecated_extract_struct_value_address (gdbarch, - sh64_extract_struct_value_address); set_gdbarch_skip_prologue (gdbarch, sh64_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); @@ -2484,7 +2501,7 @@ sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_frame_align (gdbarch, sh64_frame_align); set_gdbarch_unwind_sp (gdbarch, sh64_unwind_sp); set_gdbarch_unwind_pc (gdbarch, sh64_unwind_pc); - set_gdbarch_unwind_dummy_id (gdbarch, sh64_unwind_dummy_id); + set_gdbarch_dummy_id (gdbarch, sh64_dummy_id); frame_base_set_default (gdbarch, &sh64_frame_base); set_gdbarch_print_registers_info (gdbarch, sh64_print_registers_info); @@ -2495,8 +2512,8 @@ sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); - frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); - frame_unwind_append_sniffer (gdbarch, sh64_frame_sniffer); + dwarf2_append_unwinders (gdbarch); + frame_unwind_append_unwinder (gdbarch, &sh64_frame_unwind); return gdbarch; }