/* Target-dependent code for Renesas Super-H, for GDB.
- Copyright (C) 1993-2014 Free Software Foundation, Inc.
+ Copyright (C) 1993-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "value.h"
#include "dis-asm.h"
#include "inferior.h"
-#include <string.h>
-#include "gdb_assert.h"
#include "arch-utils.h"
#include "regcache.h"
#include "osabi.h"
#include "gdb/sim-sh.h"
#include "language.h"
#include "sh64-tdep.h"
+#include <algorithm>
/* Information that is dependent on the processor variant. */
enum sh_abi
struct gdbarch_tdep
{
enum sh_abi sh_abi;
+ /* ISA-specific data types. */
+ struct type *sh_littlebyte_bigword_type;
};
+struct type *
+sh64_littlebyte_bigword_type (struct gdbarch *gdbarch)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+ if (tdep->sh_littlebyte_bigword_type == NULL)
+ tdep->sh_littlebyte_bigword_type
+ = arch_float_type (gdbarch, -1, "builtin_type_sh_littlebyte_bigword",
+ floatformats_ieee_double_littlebyte_bigword);
+
+ return tdep->sh_littlebyte_bigword_type;
+}
+
struct sh64_frame_cache
{
/* Base address. */
static const char *
sh64_register_name (struct gdbarch *gdbarch, int reg_nr)
{
- static char *register_names[] =
+ static const char *register_names[] =
{
/* SH MEDIA MODE (ISA 32) */
/* general registers (64-bit) 0-63 */
if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
{
MSYMBOL_TARGET_FLAG_1 (msym) = 1;
- SYMBOL_VALUE_ADDRESS (msym) |= 1;
+ SET_MSYMBOL_VALUE_ADDRESS (msym, MSYMBOL_VALUE_RAW_ADDRESS (msym) | 1);
}
}
return 0;
}
-static const unsigned char *
-sh64_breakpoint_from_pc (struct gdbarch *gdbarch,
- CORE_ADDR *pcptr, int *lenptr)
+static int
+sh64_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
+{
+ if (pc_is_isa32 (*pcptr))
+ {
+ *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
+ return 4;
+ }
+ else
+ return 2;
+}
+
+static const gdb_byte *
+sh64_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
{
- /* The BRK instruction for shmedia is
+ *size = kind;
+
+ /* The BRK instruction for shmedia is
01101111 11110101 11111111 11110000
which translates in big endian mode to 0x6f, 0xf5, 0xff, 0xf0
and in little endian mode to 0xf0, 0xff, 0xf5, 0x6f */
which translates in big endian mode to 0x0, 0x3b
and in little endian mode to 0x3b, 0x0 */
- if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+ if (kind == 4)
{
- if (pc_is_isa32 (*pcptr))
- {
- static unsigned char big_breakpoint_media[] = {
- 0x6f, 0xf5, 0xff, 0xf0
- };
- *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
- *lenptr = sizeof (big_breakpoint_media);
- return big_breakpoint_media;
- }
+ static unsigned char big_breakpoint_media[] = {
+ 0x6f, 0xf5, 0xff, 0xf0
+ };
+ static unsigned char little_breakpoint_media[] = {
+ 0xf0, 0xff, 0xf5, 0x6f
+ };
+
+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+ return big_breakpoint_media;
else
- {
- static unsigned char big_breakpoint_compact[] = {0x0, 0x3b};
- *lenptr = sizeof (big_breakpoint_compact);
- return big_breakpoint_compact;
- }
+ return little_breakpoint_media;
}
else
{
- if (pc_is_isa32 (*pcptr))
- {
- static unsigned char little_breakpoint_media[] = {
- 0xf0, 0xff, 0xf5, 0x6f
- };
- *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
- *lenptr = sizeof (little_breakpoint_media);
- return little_breakpoint_media;
- }
+ static unsigned char big_breakpoint_compact[] = {0x0, 0x3b};
+ static unsigned char little_breakpoint_compact[] = {0x3b, 0x0};
+
+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+ return big_breakpoint_compact;
else
- {
- static unsigned char little_breakpoint_compact[] = {0x3b, 0x0};
- *lenptr = sizeof (little_breakpoint_compact);
- return little_breakpoint_compact;
- }
+ return little_breakpoint_compact;
}
}
/* If after_prologue returned a useful address, then use it. Else
fall back on the instruction skipping code. */
if (post_prologue_pc != 0)
- return max (pc, post_prologue_pc);
+ return std::max (pc, post_prologue_pc);
else
return sh64_skip_prologue_hard_way (gdbarch, pc);
}
int insn;
int r0_val = 0;
int insn_size;
- 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;
}
else if (IS_MOV_R14 (insn))
- cache->saved_regs[MEDIA_FP_REGNUM] =
- cache->sp_offset - ((((insn & 0xf) ^ 0x8) - 0x8) << 2);
+ {
+ cache->saved_regs[MEDIA_FP_REGNUM] =
+ cache->sp_offset - ((((insn & 0xf) ^ 0x8) - 0x8) << 2);
+ cache->uses_fp = 1;
+ }
else if (IS_MOV_R0 (insn))
{
/* Store R14 at r0_val-4 from SP. Decrement r0 by 4. */
cache->saved_regs[MEDIA_FP_REGNUM] = cache->sp_offset
- (r0_val - 4);
+ cache->uses_fp = 1;
r0_val -= 4;
}
9) << 2);
else if (IS_STQ_R14_R15 (insn))
- cache->saved_regs[MEDIA_FP_REGNUM]
- = cache->sp_offset - (sign_extend ((insn & 0xffc00) >> 10,
- 9) << 3);
+ {
+ cache->saved_regs[MEDIA_FP_REGNUM]
+ = cache->sp_offset - (sign_extend ((insn & 0xffc00) >> 10,
+ 9) << 3);
+ cache->uses_fp = 1;
+ }
else if (IS_STL_R14_R15 (insn))
- cache->saved_regs[MEDIA_FP_REGNUM]
- = cache->sp_offset - (sign_extend ((insn & 0xffc00) >> 10,
- 9) << 2);
+ {
+ cache->saved_regs[MEDIA_FP_REGNUM]
+ = cache->sp_offset - (sign_extend ((insn & 0xffc00) >> 10,
+ 9) << 2);
+ cache->uses_fp = 1;
+ }
else if (IS_MOV_SP_FP_MEDIA (insn))
break;
}
}
-
- if (cache->saved_regs[MEDIA_FP_REGNUM] >= 0)
- cache->uses_fp = 1;
}
static CORE_ADDR
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int stack_offset, stack_alloc;
int int_argreg;
- int float_argreg;
- int double_argreg;
int float_arg_index = 0;
int double_arg_index = 0;
int argnum;
in eight registers available. Loop thru args from first to last. */
int_argreg = ARG0_REGNUM;
- float_argreg = gdbarch_fp0_regnum (gdbarch);
- double_argreg = DR0_REGNUM;
for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
{
TYPE, and copy that, in virtual format, into VALBUF. */
static void
sh64_extract_return_value (struct type *type, struct regcache *regcache,
- void *valbuf)
+ gdb_byte *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)
else if (len == 8)
{
/* return value stored in DR0_REGNUM. */
- DOUBLEST val;
gdb_byte buf[8];
-
regcache_cooked_read (regcache, DR0_REGNUM, buf);
- if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
- floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
- buf, &val);
- else
- floatformat_to_doublest (&floatformat_ieee_double_big,
- buf, &val);
- store_typed_floating (valbuf, type, val);
+ convert_typed_floating (buf, sh64_littlebyte_bigword_type (gdbarch),
+ valbuf, type);
}
}
else
&& regnum <= DR_LAST_REGNUM)
|| (regnum >= DR0_C_REGNUM
&& regnum <= DR_LAST_C_REGNUM))
- {
- DOUBLEST val;
- floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
- from, &val);
- store_typed_floating (to, type, val);
- }
+ convert_typed_floating (from, sh64_littlebyte_bigword_type (gdbarch),
+ to, type);
else
error (_("sh64_register_convert_to_virtual "
"called with non DR register number"));
&& regnum <= DR_LAST_REGNUM)
|| (regnum >= DR0_C_REGNUM
&& regnum <= DR_LAST_C_REGNUM))
- {
- DOUBLEST val = extract_typed_floating (from, type);
- floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
- &val, to);
- }
+ convert_typed_floating (from, type,
+ to, sh64_littlebyte_bigword_type (gdbarch));
else
error (_("sh64_register_convert_to_raw called "
"with non DR register number"));
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int base_regnum;
int offset = 0;
- gdb_byte temp_buffer[MAX_REGISTER_SIZE];
enum register_status status;
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr);
/* Build the value in the provided buffer. */
else if (reg_nr >= R0_C_REGNUM
&& reg_nr <= T_C_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
/* Build the value in the provided buffer. */
else if (reg_nr >= DR0_C_REGNUM
&& reg_nr <= DR_LAST_C_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
/* DR_C regs are double precision registers obtained by
{
int fpscr_base_regnum;
int sr_base_regnum;
- unsigned int fpscr_value;
- unsigned int sr_value;
+ ULONGEST fpscr_value;
+ ULONGEST sr_value;
unsigned int fpscr_c_value;
unsigned int fpscr_c_part1_value;
unsigned int fpscr_c_part2_value;
21-31 reserved
*/
/* *INDENT-ON* */
- /* Get FPSCR into a local buffer. */
- status = regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
+ /* Get FPSCR as an int. */
+ status = regcache->raw_read (fpscr_base_regnum, &fpscr_value);
if (status != REG_VALID)
return status;
- /* Get value as an int. */
- fpscr_value = extract_unsigned_integer (temp_buffer, 4, byte_order);
- /* Get SR into a local buffer */
- status = regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
+ /* Get SR as an int. */
+ status = regcache->raw_read (sr_base_regnum, &sr_value);
if (status != REG_VALID)
return status;
- /* Get value as an int. */
- 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;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int base_regnum, portion;
int offset;
- gdb_byte temp_buffer[MAX_REGISTER_SIZE];
if (reg_nr >= DR0_REGNUM
&& reg_nr <= DR_LAST_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_dr_reg_base_num (gdbarch, reg_nr);
/* We must pay attention to the endianness. */
sh64_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr),
else if (reg_nr >= R0_C_REGNUM
&& reg_nr <= T_C_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
/* reg_nr is 32 bit here, and base_regnum is 64 bits. */
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
else if (reg_nr >= DR0_C_REGNUM
&& reg_nr <= DR_LAST_C_REGNUM)
{
+ gdb_byte temp_buffer[8];
base_regnum = sh64_compact_reg_base_num (gdbarch, reg_nr);
for (portion = 0; portion < 2; portion++)
{
{
int fpscr_base_regnum;
int sr_base_regnum;
- unsigned int fpscr_value;
- unsigned int sr_value;
- unsigned int old_fpscr_value;
- unsigned int old_sr_value;
+ ULONGEST fpscr_value;
+ ULONGEST sr_value;
+ ULONGEST old_fpscr_value;
+ ULONGEST old_sr_value;
unsigned int fpscr_c_value;
unsigned int fpscr_mask;
unsigned int sr_mask;
fpscr_value = fpscr_c_value & fpscr_mask;
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, byte_order);
+ regcache->raw_read (fpscr_base_regnum, &old_fpscr_value);
old_fpscr_value &= 0xfffc0002;
fpscr_value |= old_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, byte_order);
+ regcache->raw_write (fpscr_base_regnum, fpscr_value);
+
+ regcache->raw_read (sr_base_regnum, &old_sr_value);
old_sr_value &= 0xffff8fff;
sr_value |= old_sr_value;
- store_unsigned_integer (temp_buffer, 4, byte_order, sr_value);
- regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
+ regcache->raw_write (sr_base_regnum, sr_value);
}
else if (reg_nr == FPUL_C_REGNUM)
struct frame_info *frame, int regnum)
{ /* Do values for FP (float) regs. */
unsigned char *raw_buffer;
- double flt; /* Double extracted from raw hex data. */
- int inv;
- int j;
/* Allocate space for the float. */
raw_buffer = (unsigned char *)
error (_("can't read register %d (%s)"),
regnum, gdbarch_register_name (gdbarch, regnum));
- /* Get the register as a number. */
- flt = unpack_double (builtin_type (gdbarch)->builtin_float,
- raw_buffer, &inv);
-
/* Print the name and some spaces. */
fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
print_spaces_filtered (15 - strlen (gdbarch_register_name
(gdbarch, regnum)), file);
/* Print the value. */
- if (inv)
- fprintf_filtered (file, "<invalid float>");
- else
- fprintf_filtered (file, "%-10.9g", flt);
+ const struct floatformat *fmt
+ = floatformat_from_type (builtin_type (gdbarch)->builtin_float);
+ std::string str = floatformat_to_string (fmt, raw_buffer, "%-10.9g");
+ fprintf_filtered (file, "%s", str.c_str ());
/* Print the fp register as hex. */
fprintf_filtered (file, "\t(raw ");
print_hex_chars (file, raw_buffer,
register_size (gdbarch, regnum),
- gdbarch_byte_order (gdbarch));
+ gdbarch_byte_order (gdbarch), true);
fprintf_filtered (file, ")");
fprintf_filtered (file, "\n");
}
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;
+ struct value *val;
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 (!deprecated_frame_register_read (frame, regnum, raw_buffer))
+ val = get_frame_register_value (frame, regnum);
+ if (value_optimized_out (val) || !value_entirely_available (val))
{
fprintf_filtered (file, "*value not available*\n");
return;
get_formatted_print_options (&opts, 'x');
opts.deref_ref = 1;
- val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
- file, 0, NULL, &opts, current_language);
+ val_print (register_type (gdbarch, regnum),
+ 0, 0,
+ file, 0, val, &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, NULL, &opts, current_language);
+ val_print (register_type (gdbarch, regnum),
+ 0, 0,
+ file, 0, val, &opts, current_language);
fprintf_filtered (file, "\n");
}
int i;
if (*this_cache)
- return *this_cache;
+ return (struct sh64_frame_cache *) *this_cache;
gdbarch = get_frame_arch (this_frame);
cache = sh64_alloc_frame_cache ();
/* None found, create a new architecture from the information
provided. */
- tdep = XNEW (struct gdbarch_tdep);
+ tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* Determine the ABI */
set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
- set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc);
-
- set_gdbarch_print_insn (gdbarch, print_insn_sh);
+ set_gdbarch_breakpoint_kind_from_pc (gdbarch, sh64_breakpoint_kind_from_pc);
+ set_gdbarch_sw_breakpoint_from_kind (gdbarch, sh64_sw_breakpoint_from_kind);
set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
set_gdbarch_return_value (gdbarch, sh64_return_value);