R3_REGNUM = 3,
D10V_FP_REGNUM = 11,
LR_REGNUM = 13,
- _SP_REGNUM = 15,
+ D10V_SP_REGNUM = 15,
PSW_REGNUM = 16,
_PC_REGNUM = 18,
NR_IMAP_REGS = 2,
RET1_REGNUM = R0_REGNUM,
};
-#define NR_DMAP_REGS (gdbarch_tdep (current_gdbarch)->nr_dmap_regs)
-#define A0_REGNUM (gdbarch_tdep (current_gdbarch)->a0_regnum)
+int
+nr_dmap_regs (struct gdbarch *gdbarch)
+{
+ return gdbarch_tdep (gdbarch)->nr_dmap_regs;
+}
+
+int
+a0_regnum (struct gdbarch *gdbarch)
+{
+ return gdbarch_tdep (gdbarch)->a0_regnum;
+}
/* Local functions */
return nr;
}
-/* Index within `registers' of the first byte of the space for
- register REG_NR. */
-
-static int
-d10v_register_byte (int reg_nr)
-{
- if (reg_nr < A0_REGNUM)
- return (reg_nr * 2);
- else if (reg_nr < (A0_REGNUM + NR_A_REGS))
- return (A0_REGNUM * 2
- + (reg_nr - A0_REGNUM) * 8);
- else
- return (A0_REGNUM * 2
- + NR_A_REGS * 8
- + (reg_nr - A0_REGNUM - NR_A_REGS) * 2);
-}
-
-/* Number of bytes of storage in the actual machine representation for
- register REG_NR. */
-
-static int
-d10v_register_raw_size (int reg_nr)
-{
- if (reg_nr < A0_REGNUM)
- return 2;
- else if (reg_nr < (A0_REGNUM + NR_A_REGS))
- return 8;
- else
- return 2;
-}
-
/* Return the GDB type object for the "standard" data type
of data in register N. */
{
if (reg_nr == PC_REGNUM)
return builtin_type_void_func_ptr;
- if (reg_nr == _SP_REGNUM || reg_nr == D10V_FP_REGNUM)
+ if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM)
return builtin_type_void_data_ptr;
- else if (reg_nr >= A0_REGNUM
- && reg_nr < (A0_REGNUM + NR_A_REGS))
+ else if (reg_nr >= a0_regnum (gdbarch)
+ && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS))
return builtin_type_int64;
else
return builtin_type_int16;
static CORE_ADDR
d10v_pointer_to_address (struct type *type, const void *buf)
{
- CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
-
+ CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
/* Is it a code address? */
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache);
(*this_prologue_cache) = info;
- info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
+ info->saved_regs = FRAME_OBSTACK_CALLOC (NUM_REGS, CORE_ADDR);
info->size = 0;
info->return_pc = 0;
to before the first saved register giving the SP. */
prev_sp = this_base + info->size;
}
- else if (info->saved_regs[SP_REGNUM])
+ else if (info->saved_regs[D10V_SP_REGNUM])
{
/* The SP was saved (which is very unusual), the frame base is
just the PREV's frame's TOP-OF-STACK. */
- this_base = read_memory_unsigned_integer (info->saved_regs[SP_REGNUM],
+ this_base = read_memory_unsigned_integer (info->saved_regs[D10V_SP_REGNUM],
register_size (current_gdbarch,
- SP_REGNUM));
+ D10V_SP_REGNUM));
prev_sp = this_base;
}
else
{
/* Assume that the FP is this frame's SP but with that pushed
stack space added back. */
- frame_unwind_unsigned_register (next_frame, SP_REGNUM, &this_base);
+ frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base);
prev_sp = this_base + info->size;
}
info->return_pc = d10v_make_iaddr (return_pc);
}
- /* The SP_REGNUM is special. Instead of the address of the SP, the
+ /* The D10V_SP_REGNUM is special. Instead of the address of the SP, the
previous frame's SP value is saved. */
- info->saved_regs[SP_REGNUM] = info->prev_sp;
+ info->saved_regs[D10V_SP_REGNUM] = info->prev_sp;
return info;
}
fprintf_filtered (file, " ");
fprintf_filtered (file, "IMAP%d %04lx", a, d10v_imap_register (a));
}
- if (NR_DMAP_REGS == 1)
+ if (nr_dmap_regs (gdbarch) == 1)
/* Registers DMAP0 and DMAP1 are constant. Just return dmap2. */
fprintf_filtered (file, " DMAP %04lx\n", d10v_dmap_register (2));
else
{
- for (a = 0; a < NR_DMAP_REGS; a++)
+ for (a = 0; a < nr_dmap_regs (gdbarch); a++)
{
fprintf_filtered (file, " DMAP%d %04lx", a, d10v_dmap_register (a));
}
char *num = alloca (max_register_size (gdbarch));
int a;
fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1);
- for (a = A0_REGNUM; a < A0_REGNUM + NR_A_REGS; a++)
+ for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++)
{
int i;
fprintf_filtered (file, " ");
- frame_register_read (frame, a, num);
- for (i = 0; i < max_register_size (current_gdbarch); i++)
+ frame_read_register (frame, a, num);
+ for (i = 0; i < register_size (current_gdbarch, a); i++)
{
fprintf_filtered (file, "%02x", (num[i] & 0xff));
}
static CORE_ADDR
d10v_read_sp (void)
{
- return (d10v_make_daddr (read_register (SP_REGNUM)));
+ return (d10v_make_daddr (read_register (D10V_SP_REGNUM)));
}
static CORE_ADDR
}
/* Finally, update the SP register. */
- regcache_cooked_write_unsigned (regcache, SP_REGNUM,
+ regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM,
d10v_convert_daddr_to_raw (sp));
return sp;
void *valbuf)
{
int len;
-#if 0
- printf("RET: TYPE=%d len=%d r%d=0x%x\n", TYPE_CODE (type),
- TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM,
- (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM),
- register_size (current_gdbarch, RET1_REGNUM)));
-#endif
if (TYPE_LENGTH (type) == 1)
{
ULONGEST c;
/* Clear the host-side trace buffer, allocating space if needed. */
trace_data.size = 0;
if (trace_data.counts == NULL)
- trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
+ trace_data.counts = XCALLOC (65536, short);
if (trace_data.addrs == NULL)
- trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
+ trace_data.addrs = XCALLOC (65536, CORE_ADDR);
tracing = 1;
static int
print_insn (CORE_ADDR memaddr, struct ui_file *stream)
{
- /* If there's no disassembler, something is very wrong. */
- if (tm_print_insn == NULL)
- internal_error (__FILE__, __LINE__,
- "print_insn: no disassembler");
-
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
tm_print_insn_info.endian = BFD_ENDIAN_BIG;
else
{
if (this_saved_regs[regnum] != 0)
{
- if (regnum == SP_REGNUM)
+ if (regnum == D10V_SP_REGNUM)
{
/* SP register treated specially. */
*optimizedp = 0;
*addrp = 0;
*realnump = -1;
if (bufferp != NULL)
- store_address (bufferp, register_size (current_gdbarch, regnum),
- this_saved_regs[regnum]);
+ store_unsigned_integer (bufferp,
+ register_size (current_gdbarch, regnum),
+ this_saved_regs[regnum]);
}
else
{
d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
ULONGEST base;
- frame_unwind_unsigned_register (next_frame, SP_REGNUM, &base);
+ frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &base);
return frame_id_build (d10v_make_daddr (base), frame_pc_unwind (next_frame));
}
set_gdbarch_read_sp (gdbarch, d10v_read_sp);
set_gdbarch_num_regs (gdbarch, d10v_num_regs);
- set_gdbarch_sp_regnum (gdbarch, 15);
+ set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, 18);
set_gdbarch_register_name (gdbarch, d10v_register_name);
set_gdbarch_register_size (gdbarch, 2);
set_gdbarch_register_bytes (gdbarch, (d10v_num_regs - 2) * 2 + 16);
- set_gdbarch_register_byte (gdbarch, d10v_register_byte);
- set_gdbarch_register_raw_size (gdbarch, d10v_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, generic_register_size);
set_gdbarch_register_type (gdbarch, d10v_register_type);
add_info ("itrace", trace_info,
"Display info about the trace data buffer.");
- add_show_from_set (add_set_cmd ("itracedisplay", no_class,
- var_integer, (char *) &trace_display,
- "Set automatic display of trace.\n", &setlist),
- &showlist);
- add_show_from_set (add_set_cmd ("itracesource", no_class,
- var_integer, (char *) &default_trace_show_source,
- "Set display of source code with trace.\n", &setlist),
- &showlist);
-
+ add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display,
+ "Set automatic display of trace.\n",
+ "Show automatic display of trace.\n",
+ NULL, NULL, &setlist, &showlist);
+ add_setshow_boolean_cmd ("itracesource", no_class,
+ &default_trace_show_source,
+ "Set display of source code with trace.\n",
+ "Show display of source code with trace.\n",
+ NULL, NULL, &setlist, &showlist);
}
projects / binutils-gdb.git / commitdiff