2012-02-04 14:05:50 +08:00
|
|
|
/* Target-dependent code for the Renesas RL78 for GDB, the GNU debugger.
|
|
|
|
|
|
2017-01-01 14:50:51 +08:00
|
|
|
Copyright (C) 2011-2017 Free Software Foundation, Inc.
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
Contributed by Red Hat, 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 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
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, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "arch-utils.h"
|
|
|
|
|
#include "prologue-value.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "regcache.h"
|
|
|
|
|
#include "opcode/rl78.h"
|
|
|
|
|
#include "dis-asm.h"
|
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "frame-unwind.h"
|
|
|
|
|
#include "frame-base.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "gdbcore.h"
|
|
|
|
|
#include "dwarf2-frame.h"
|
2012-02-15 04:15:44 +08:00
|
|
|
#include "reggroups.h"
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
#include "elf/rl78.h"
|
|
|
|
|
#include "elf-bfd.h"
|
|
|
|
|
|
|
|
|
|
/* Register Banks. */
|
|
|
|
|
|
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
RL78_BANK0 = 0,
|
|
|
|
|
RL78_BANK1 = 1,
|
|
|
|
|
RL78_BANK2 = 2,
|
|
|
|
|
RL78_BANK3 = 3,
|
|
|
|
|
RL78_NUMBANKS = 4,
|
|
|
|
|
RL78_REGS_PER_BANK = 8
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Register Numbers. */
|
|
|
|
|
|
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
/* All general purpose registers are 8 bits wide. */
|
2012-02-15 04:15:44 +08:00
|
|
|
RL78_RAW_BANK0_R0_REGNUM = 0,
|
|
|
|
|
RL78_RAW_BANK0_R1_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R2_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R3_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R4_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R5_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R6_REGNUM,
|
|
|
|
|
RL78_RAW_BANK0_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_RAW_BANK1_R0_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R1_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R2_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R3_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R4_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R5_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R6_REGNUM,
|
|
|
|
|
RL78_RAW_BANK1_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_RAW_BANK2_R0_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R1_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R2_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R3_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R4_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R5_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R6_REGNUM,
|
|
|
|
|
RL78_RAW_BANK2_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_RAW_BANK3_R0_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R1_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R2_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R3_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R4_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R5_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R6_REGNUM,
|
|
|
|
|
RL78_RAW_BANK3_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_PSW_REGNUM, /* 8 bits */
|
|
|
|
|
RL78_ES_REGNUM, /* 8 bits */
|
|
|
|
|
RL78_CS_REGNUM, /* 8 bits */
|
2013-08-16 12:30:23 +08:00
|
|
|
RL78_RAW_PC_REGNUM, /* 20 bits; we'll use 32 bits for it. */
|
2012-02-15 04:15:44 +08:00
|
|
|
|
|
|
|
|
/* Fixed address SFRs (some of those above are SFRs too.) */
|
|
|
|
|
RL78_SPL_REGNUM, /* 8 bits; lower half of SP */
|
|
|
|
|
RL78_SPH_REGNUM, /* 8 bits; upper half of SP */
|
|
|
|
|
RL78_PMC_REGNUM, /* 8 bits */
|
|
|
|
|
RL78_MEM_REGNUM, /* 8 bits ?? */
|
|
|
|
|
|
|
|
|
|
RL78_NUM_REGS,
|
|
|
|
|
|
|
|
|
|
/* Pseudo registers. */
|
2013-08-16 12:30:23 +08:00
|
|
|
RL78_PC_REGNUM = RL78_NUM_REGS,
|
|
|
|
|
RL78_SP_REGNUM,
|
2012-02-15 04:15:44 +08:00
|
|
|
|
|
|
|
|
RL78_X_REGNUM,
|
|
|
|
|
RL78_A_REGNUM,
|
|
|
|
|
RL78_C_REGNUM,
|
|
|
|
|
RL78_B_REGNUM,
|
|
|
|
|
RL78_E_REGNUM,
|
|
|
|
|
RL78_D_REGNUM,
|
|
|
|
|
RL78_L_REGNUM,
|
|
|
|
|
RL78_H_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_AX_REGNUM,
|
|
|
|
|
RL78_BC_REGNUM,
|
|
|
|
|
RL78_DE_REGNUM,
|
|
|
|
|
RL78_HL_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK0_R0_REGNUM,
|
2012-02-04 14:05:50 +08:00
|
|
|
RL78_BANK0_R1_REGNUM,
|
|
|
|
|
RL78_BANK0_R2_REGNUM,
|
|
|
|
|
RL78_BANK0_R3_REGNUM,
|
|
|
|
|
RL78_BANK0_R4_REGNUM,
|
|
|
|
|
RL78_BANK0_R5_REGNUM,
|
|
|
|
|
RL78_BANK0_R6_REGNUM,
|
|
|
|
|
RL78_BANK0_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK1_R0_REGNUM,
|
|
|
|
|
RL78_BANK1_R1_REGNUM,
|
|
|
|
|
RL78_BANK1_R2_REGNUM,
|
|
|
|
|
RL78_BANK1_R3_REGNUM,
|
|
|
|
|
RL78_BANK1_R4_REGNUM,
|
|
|
|
|
RL78_BANK1_R5_REGNUM,
|
|
|
|
|
RL78_BANK1_R6_REGNUM,
|
|
|
|
|
RL78_BANK1_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK2_R0_REGNUM,
|
|
|
|
|
RL78_BANK2_R1_REGNUM,
|
|
|
|
|
RL78_BANK2_R2_REGNUM,
|
|
|
|
|
RL78_BANK2_R3_REGNUM,
|
|
|
|
|
RL78_BANK2_R4_REGNUM,
|
|
|
|
|
RL78_BANK2_R5_REGNUM,
|
|
|
|
|
RL78_BANK2_R6_REGNUM,
|
|
|
|
|
RL78_BANK2_R7_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK3_R0_REGNUM,
|
|
|
|
|
RL78_BANK3_R1_REGNUM,
|
|
|
|
|
RL78_BANK3_R2_REGNUM,
|
|
|
|
|
RL78_BANK3_R3_REGNUM,
|
|
|
|
|
RL78_BANK3_R4_REGNUM,
|
|
|
|
|
RL78_BANK3_R5_REGNUM,
|
|
|
|
|
RL78_BANK3_R6_REGNUM,
|
|
|
|
|
RL78_BANK3_R7_REGNUM,
|
|
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
RL78_BANK0_RP0_REGNUM,
|
2012-02-04 14:05:50 +08:00
|
|
|
RL78_BANK0_RP1_REGNUM,
|
|
|
|
|
RL78_BANK0_RP2_REGNUM,
|
|
|
|
|
RL78_BANK0_RP3_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK1_RP0_REGNUM,
|
|
|
|
|
RL78_BANK1_RP1_REGNUM,
|
|
|
|
|
RL78_BANK1_RP2_REGNUM,
|
|
|
|
|
RL78_BANK1_RP3_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK2_RP0_REGNUM,
|
|
|
|
|
RL78_BANK2_RP1_REGNUM,
|
|
|
|
|
RL78_BANK2_RP2_REGNUM,
|
|
|
|
|
RL78_BANK2_RP3_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK3_RP0_REGNUM,
|
|
|
|
|
RL78_BANK3_RP1_REGNUM,
|
|
|
|
|
RL78_BANK3_RP2_REGNUM,
|
|
|
|
|
RL78_BANK3_RP3_REGNUM,
|
|
|
|
|
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
/* These are the same as the above 16 registers, but have
|
|
|
|
|
a pointer type for use as base registers in expression
|
|
|
|
|
evaluation. These are not user visible registers. */
|
|
|
|
|
RL78_BANK0_RP0_PTR_REGNUM,
|
|
|
|
|
RL78_BANK0_RP1_PTR_REGNUM,
|
|
|
|
|
RL78_BANK0_RP2_PTR_REGNUM,
|
|
|
|
|
RL78_BANK0_RP3_PTR_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK1_RP0_PTR_REGNUM,
|
|
|
|
|
RL78_BANK1_RP1_PTR_REGNUM,
|
|
|
|
|
RL78_BANK1_RP2_PTR_REGNUM,
|
|
|
|
|
RL78_BANK1_RP3_PTR_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK2_RP0_PTR_REGNUM,
|
|
|
|
|
RL78_BANK2_RP1_PTR_REGNUM,
|
|
|
|
|
RL78_BANK2_RP2_PTR_REGNUM,
|
|
|
|
|
RL78_BANK2_RP3_PTR_REGNUM,
|
|
|
|
|
|
|
|
|
|
RL78_BANK3_RP0_PTR_REGNUM,
|
|
|
|
|
RL78_BANK3_RP1_PTR_REGNUM,
|
|
|
|
|
RL78_BANK3_RP2_PTR_REGNUM,
|
|
|
|
|
RL78_BANK3_RP3_PTR_REGNUM,
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
RL78_NUM_TOTAL_REGS,
|
|
|
|
|
RL78_NUM_PSEUDO_REGS = RL78_NUM_TOTAL_REGS - RL78_NUM_REGS
|
|
|
|
|
};
|
|
|
|
|
|
2015-04-21 14:37:44 +08:00
|
|
|
#define RL78_SP_ADDR 0xffff8
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
/* Architecture specific data. */
|
|
|
|
|
|
|
|
|
|
struct gdbarch_tdep
|
|
|
|
|
{
|
|
|
|
|
/* The ELF header flags specify the multilib used. */
|
|
|
|
|
int elf_flags;
|
|
|
|
|
|
|
|
|
|
struct type *rl78_void,
|
|
|
|
|
*rl78_uint8,
|
|
|
|
|
*rl78_int8,
|
|
|
|
|
*rl78_uint16,
|
|
|
|
|
*rl78_int16,
|
|
|
|
|
*rl78_uint32,
|
|
|
|
|
*rl78_int32,
|
|
|
|
|
*rl78_data_pointer,
|
2015-07-02 07:18:35 +08:00
|
|
|
*rl78_code_pointer,
|
|
|
|
|
*rl78_psw_type;
|
2012-02-04 14:05:50 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* This structure holds the results of a prologue analysis. */
|
|
|
|
|
|
|
|
|
|
struct rl78_prologue
|
|
|
|
|
{
|
|
|
|
|
/* The offset from the frame base to the stack pointer --- always
|
|
|
|
|
zero or negative.
|
|
|
|
|
|
|
|
|
|
Calling this a "size" is a bit misleading, but given that the
|
|
|
|
|
stack grows downwards, using offsets for everything keeps one
|
|
|
|
|
from going completely sign-crazy: you never change anything's
|
|
|
|
|
sign for an ADD instruction; always change the second operand's
|
|
|
|
|
sign for a SUB instruction; and everything takes care of
|
|
|
|
|
itself. */
|
|
|
|
|
int frame_size;
|
|
|
|
|
|
|
|
|
|
/* Non-zero if this function has initialized the frame pointer from
|
|
|
|
|
the stack pointer, zero otherwise. */
|
|
|
|
|
int has_frame_ptr;
|
|
|
|
|
|
|
|
|
|
/* If has_frame_ptr is non-zero, this is the offset from the frame
|
|
|
|
|
base to where the frame pointer points. This is always zero or
|
|
|
|
|
negative. */
|
|
|
|
|
int frame_ptr_offset;
|
|
|
|
|
|
|
|
|
|
/* The address of the first instruction at which the frame has been
|
|
|
|
|
set up and the arguments are where the debug info says they are
|
|
|
|
|
--- as best as we can tell. */
|
|
|
|
|
CORE_ADDR prologue_end;
|
|
|
|
|
|
|
|
|
|
/* reg_offset[R] is the offset from the CFA at which register R is
|
|
|
|
|
saved, or 1 if register R has not been saved. (Real values are
|
|
|
|
|
always zero or negative.) */
|
|
|
|
|
int reg_offset[RL78_NUM_TOTAL_REGS];
|
|
|
|
|
};
|
|
|
|
|
|
Create tdep->rl78_psw_type lazily
I build GDB for all targets enabled. When I "set architecture rl78",
GDB crashes,
(gdb) set architecture rl78
Program received signal SIGSEGV, Segmentation fault.
append_flags_type_flag (type=0x20cc0e0, bitpos=bitpos@entry=0, name=name@entry=0x11dba3f "CY") at ../../binutils-gdb/gdb/gdbtypes.c:4926
4926 name);
(gdb) bt 10
#0 append_flags_type_flag (type=0x20cc0e0, bitpos=bitpos@entry=0, name=name@entry=0x11dba3f "CY") at ../../binutils-gdb/gdb/gdbtypes.c:4926
#1 0x00000000004aaca8 in rl78_gdbarch_init (info=..., arches=<optimized out>) at ../../binutils-gdb/gdb/rl78-tdep.c:1410
#2 0x00000000006b05a4 in gdbarch_find_by_info (info=...) at ../../binutils-gdb/gdb/gdbarch.c:5269
#3 0x000000000060eee4 in gdbarch_update_p (info=...) at ../../binutils-gdb/gdb/arch-utils.c:557
#4 0x000000000060f8a8 in set_architecture (ignore_args=<optimized out>, from_tty=1, c=<optimized out>) at ../../binutils-gdb/gdb/arch-utils.c:531
#5 0x0000000000593d0b in do_set_command (arg=<optimized out>, arg@entry=0x20be851 "rl78", from_tty=from_tty@entry=1, c=c@entry=0x20b1540)
at ../../binutils-gdb/gdb/cli/cli-setshow.c:455
#6 0x00000000007665c3 in execute_command (p=<optimized out>, p@entry=0x20be840 "set architecture rl78", from_tty=1) at ../../binutils-gdb/gdb/top.c:666
#7 0x00000000006935f4 in command_handler (command=0x20be840 "set architecture rl78") at ../../binutils-gdb/gdb/event-top.c:577
#8 0x00000000006938d8 in command_line_handler (rl=<optimized out>) at ../../binutils-gdb/gdb/event-top.c:767
#9 0x0000000000692c2c in gdb_rl_callback_handler (rl=0x20be890 "") at ../../binutils-gdb/gdb/event-top.c:200
The cause is that we want to access some builtin types in gdbarch init, but
it is not initialized yet. I fix it by creating the type when it is to be
used. We've already done this in sparc, sparc64 and m68k.
gdb:
2016-12-09 Yao Qi <yao.qi@linaro.org>
PR tdep/20953
* rl78-tdep.c (rl78_psw_type): New function.
(rl78_register_type): Call rl78_psw_type.
(rl78_gdbarch_init): Move code to rl78_psw_type.
gdb/testsuite:
2016-12-09 Yao Qi <yao.qi@linaro.org>
* gdb.base/all-architectures.exp.in: Remove kfail for rl78.
2016-12-09 23:27:43 +08:00
|
|
|
/* Construct type for PSW register. */
|
|
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
|
rl78_psw_type (struct gdbarch *gdbarch)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
|
|
|
|
|
|
|
|
|
if (tdep->rl78_psw_type == NULL)
|
|
|
|
|
{
|
|
|
|
|
tdep->rl78_psw_type = arch_flags_type (gdbarch,
|
|
|
|
|
"builtin_type_rl78_psw", 1);
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 0, "CY");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 1, "ISP0");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 2, "ISP1");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 3, "RBS0");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 4, "AC");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 5, "RBS1");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 6, "Z");
|
|
|
|
|
append_flags_type_flag (tdep->rl78_psw_type, 7, "IE");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return tdep->rl78_psw_type;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
/* Implement the "register_type" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
|
rl78_register_type (struct gdbarch *gdbarch, int reg_nr)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
|
|
|
|
|
|
|
|
|
if (reg_nr == RL78_PC_REGNUM)
|
|
|
|
|
return tdep->rl78_code_pointer;
|
2013-08-16 12:30:23 +08:00
|
|
|
else if (reg_nr == RL78_RAW_PC_REGNUM)
|
|
|
|
|
return tdep->rl78_uint32;
|
2015-07-02 07:18:35 +08:00
|
|
|
else if (reg_nr == RL78_PSW_REGNUM)
|
Create tdep->rl78_psw_type lazily
I build GDB for all targets enabled. When I "set architecture rl78",
GDB crashes,
(gdb) set architecture rl78
Program received signal SIGSEGV, Segmentation fault.
append_flags_type_flag (type=0x20cc0e0, bitpos=bitpos@entry=0, name=name@entry=0x11dba3f "CY") at ../../binutils-gdb/gdb/gdbtypes.c:4926
4926 name);
(gdb) bt 10
#0 append_flags_type_flag (type=0x20cc0e0, bitpos=bitpos@entry=0, name=name@entry=0x11dba3f "CY") at ../../binutils-gdb/gdb/gdbtypes.c:4926
#1 0x00000000004aaca8 in rl78_gdbarch_init (info=..., arches=<optimized out>) at ../../binutils-gdb/gdb/rl78-tdep.c:1410
#2 0x00000000006b05a4 in gdbarch_find_by_info (info=...) at ../../binutils-gdb/gdb/gdbarch.c:5269
#3 0x000000000060eee4 in gdbarch_update_p (info=...) at ../../binutils-gdb/gdb/arch-utils.c:557
#4 0x000000000060f8a8 in set_architecture (ignore_args=<optimized out>, from_tty=1, c=<optimized out>) at ../../binutils-gdb/gdb/arch-utils.c:531
#5 0x0000000000593d0b in do_set_command (arg=<optimized out>, arg@entry=0x20be851 "rl78", from_tty=from_tty@entry=1, c=c@entry=0x20b1540)
at ../../binutils-gdb/gdb/cli/cli-setshow.c:455
#6 0x00000000007665c3 in execute_command (p=<optimized out>, p@entry=0x20be840 "set architecture rl78", from_tty=1) at ../../binutils-gdb/gdb/top.c:666
#7 0x00000000006935f4 in command_handler (command=0x20be840 "set architecture rl78") at ../../binutils-gdb/gdb/event-top.c:577
#8 0x00000000006938d8 in command_line_handler (rl=<optimized out>) at ../../binutils-gdb/gdb/event-top.c:767
#9 0x0000000000692c2c in gdb_rl_callback_handler (rl=0x20be890 "") at ../../binutils-gdb/gdb/event-top.c:200
The cause is that we want to access some builtin types in gdbarch init, but
it is not initialized yet. I fix it by creating the type when it is to be
used. We've already done this in sparc, sparc64 and m68k.
gdb:
2016-12-09 Yao Qi <yao.qi@linaro.org>
PR tdep/20953
* rl78-tdep.c (rl78_psw_type): New function.
(rl78_register_type): Call rl78_psw_type.
(rl78_gdbarch_init): Move code to rl78_psw_type.
gdb/testsuite:
2016-12-09 Yao Qi <yao.qi@linaro.org>
* gdb.base/all-architectures.exp.in: Remove kfail for rl78.
2016-12-09 23:27:43 +08:00
|
|
|
return rl78_psw_type (gdbarch);
|
2012-02-04 14:05:50 +08:00
|
|
|
else if (reg_nr <= RL78_MEM_REGNUM
|
2012-02-15 04:15:44 +08:00
|
|
|
|| (RL78_X_REGNUM <= reg_nr && reg_nr <= RL78_H_REGNUM)
|
|
|
|
|
|| (RL78_BANK0_R0_REGNUM <= reg_nr
|
|
|
|
|
&& reg_nr <= RL78_BANK3_R7_REGNUM))
|
2012-02-04 14:05:50 +08:00
|
|
|
return tdep->rl78_int8;
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
else if (reg_nr == RL78_SP_REGNUM
|
|
|
|
|
|| (RL78_BANK0_RP0_PTR_REGNUM <= reg_nr
|
|
|
|
|
&& reg_nr <= RL78_BANK3_RP3_PTR_REGNUM))
|
2012-02-04 14:05:50 +08:00
|
|
|
return tdep->rl78_data_pointer;
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
else
|
|
|
|
|
return tdep->rl78_int16;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "register_name" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
|
rl78_register_name (struct gdbarch *gdbarch, int regnr)
|
|
|
|
|
{
|
|
|
|
|
static const char *const reg_names[] =
|
|
|
|
|
{
|
2012-02-15 04:15:44 +08:00
|
|
|
"", /* bank0_r0 */
|
|
|
|
|
"", /* bank0_r1 */
|
|
|
|
|
"", /* bank0_r2 */
|
|
|
|
|
"", /* bank0_r3 */
|
|
|
|
|
"", /* bank0_r4 */
|
|
|
|
|
"", /* bank0_r5 */
|
|
|
|
|
"", /* bank0_r6 */
|
|
|
|
|
"", /* bank0_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank1_r0 */
|
|
|
|
|
"", /* bank1_r1 */
|
|
|
|
|
"", /* bank1_r2 */
|
|
|
|
|
"", /* bank1_r3 */
|
|
|
|
|
"", /* bank1_r4 */
|
|
|
|
|
"", /* bank1_r5 */
|
|
|
|
|
"", /* bank1_r6 */
|
|
|
|
|
"", /* bank1_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank2_r0 */
|
|
|
|
|
"", /* bank2_r1 */
|
|
|
|
|
"", /* bank2_r2 */
|
|
|
|
|
"", /* bank2_r3 */
|
|
|
|
|
"", /* bank2_r4 */
|
|
|
|
|
"", /* bank2_r5 */
|
|
|
|
|
"", /* bank2_r6 */
|
|
|
|
|
"", /* bank2_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank3_r0 */
|
|
|
|
|
"", /* bank3_r1 */
|
|
|
|
|
"", /* bank3_r2 */
|
|
|
|
|
"", /* bank3_r3 */
|
|
|
|
|
"", /* bank3_r4 */
|
|
|
|
|
"", /* bank3_r5 */
|
|
|
|
|
"", /* bank3_r6 */
|
|
|
|
|
"", /* bank3_r7 */
|
|
|
|
|
|
|
|
|
|
"psw",
|
|
|
|
|
"es",
|
|
|
|
|
"cs",
|
2013-08-16 12:30:23 +08:00
|
|
|
"",
|
2012-02-15 04:15:44 +08:00
|
|
|
|
|
|
|
|
"", /* spl */
|
|
|
|
|
"", /* sph */
|
|
|
|
|
"pmc",
|
|
|
|
|
"mem",
|
|
|
|
|
|
2013-08-16 12:30:23 +08:00
|
|
|
"pc",
|
2012-02-15 04:15:44 +08:00
|
|
|
"sp",
|
|
|
|
|
|
|
|
|
|
"x",
|
|
|
|
|
"a",
|
|
|
|
|
"c",
|
|
|
|
|
"b",
|
|
|
|
|
"e",
|
|
|
|
|
"d",
|
|
|
|
|
"l",
|
|
|
|
|
"h",
|
|
|
|
|
|
|
|
|
|
"ax",
|
|
|
|
|
"bc",
|
|
|
|
|
"de",
|
|
|
|
|
"hl",
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
"bank0_r0",
|
|
|
|
|
"bank0_r1",
|
|
|
|
|
"bank0_r2",
|
|
|
|
|
"bank0_r3",
|
|
|
|
|
"bank0_r4",
|
|
|
|
|
"bank0_r5",
|
|
|
|
|
"bank0_r6",
|
|
|
|
|
"bank0_r7",
|
|
|
|
|
|
|
|
|
|
"bank1_r0",
|
|
|
|
|
"bank1_r1",
|
|
|
|
|
"bank1_r2",
|
|
|
|
|
"bank1_r3",
|
|
|
|
|
"bank1_r4",
|
|
|
|
|
"bank1_r5",
|
|
|
|
|
"bank1_r6",
|
|
|
|
|
"bank1_r7",
|
|
|
|
|
|
|
|
|
|
"bank2_r0",
|
|
|
|
|
"bank2_r1",
|
|
|
|
|
"bank2_r2",
|
|
|
|
|
"bank2_r3",
|
|
|
|
|
"bank2_r4",
|
|
|
|
|
"bank2_r5",
|
|
|
|
|
"bank2_r6",
|
|
|
|
|
"bank2_r7",
|
|
|
|
|
|
|
|
|
|
"bank3_r0",
|
|
|
|
|
"bank3_r1",
|
|
|
|
|
"bank3_r2",
|
|
|
|
|
"bank3_r3",
|
|
|
|
|
"bank3_r4",
|
|
|
|
|
"bank3_r5",
|
|
|
|
|
"bank3_r6",
|
|
|
|
|
"bank3_r7",
|
|
|
|
|
|
|
|
|
|
"bank0_rp0",
|
|
|
|
|
"bank0_rp1",
|
|
|
|
|
"bank0_rp2",
|
|
|
|
|
"bank0_rp3",
|
|
|
|
|
|
|
|
|
|
"bank1_rp0",
|
|
|
|
|
"bank1_rp1",
|
|
|
|
|
"bank1_rp2",
|
|
|
|
|
"bank1_rp3",
|
|
|
|
|
|
|
|
|
|
"bank2_rp0",
|
|
|
|
|
"bank2_rp1",
|
|
|
|
|
"bank2_rp2",
|
|
|
|
|
"bank2_rp3",
|
|
|
|
|
|
|
|
|
|
"bank3_rp0",
|
|
|
|
|
"bank3_rp1",
|
|
|
|
|
"bank3_rp2",
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
"bank3_rp3",
|
|
|
|
|
|
|
|
|
|
/* The 16 register slots would be named
|
|
|
|
|
bank0_rp0_ptr_regnum ... bank3_rp3_ptr_regnum, but we don't
|
|
|
|
|
want these to be user visible registers. */
|
|
|
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""
|
2012-02-15 04:15:44 +08:00
|
|
|
};
|
2012-02-04 14:05:50 +08:00
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
return reg_names[regnr];
|
|
|
|
|
}
|
2012-02-04 14:05:50 +08:00
|
|
|
|
2014-02-18 03:03:23 +08:00
|
|
|
/* Implement the "register_name" gdbarch method for the g10 variant. */
|
|
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
|
rl78_g10_register_name (struct gdbarch *gdbarch, int regnr)
|
|
|
|
|
{
|
|
|
|
|
static const char *const reg_names[] =
|
|
|
|
|
{
|
|
|
|
|
"", /* bank0_r0 */
|
|
|
|
|
"", /* bank0_r1 */
|
|
|
|
|
"", /* bank0_r2 */
|
|
|
|
|
"", /* bank0_r3 */
|
|
|
|
|
"", /* bank0_r4 */
|
|
|
|
|
"", /* bank0_r5 */
|
|
|
|
|
"", /* bank0_r6 */
|
|
|
|
|
"", /* bank0_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank1_r0 */
|
|
|
|
|
"", /* bank1_r1 */
|
|
|
|
|
"", /* bank1_r2 */
|
|
|
|
|
"", /* bank1_r3 */
|
|
|
|
|
"", /* bank1_r4 */
|
|
|
|
|
"", /* bank1_r5 */
|
|
|
|
|
"", /* bank1_r6 */
|
|
|
|
|
"", /* bank1_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank2_r0 */
|
|
|
|
|
"", /* bank2_r1 */
|
|
|
|
|
"", /* bank2_r2 */
|
|
|
|
|
"", /* bank2_r3 */
|
|
|
|
|
"", /* bank2_r4 */
|
|
|
|
|
"", /* bank2_r5 */
|
|
|
|
|
"", /* bank2_r6 */
|
|
|
|
|
"", /* bank2_r7 */
|
|
|
|
|
|
|
|
|
|
"", /* bank3_r0 */
|
|
|
|
|
"", /* bank3_r1 */
|
|
|
|
|
"", /* bank3_r2 */
|
|
|
|
|
"", /* bank3_r3 */
|
|
|
|
|
"", /* bank3_r4 */
|
|
|
|
|
"", /* bank3_r5 */
|
|
|
|
|
"", /* bank3_r6 */
|
|
|
|
|
"", /* bank3_r7 */
|
|
|
|
|
|
|
|
|
|
"psw",
|
|
|
|
|
"es",
|
|
|
|
|
"cs",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"", /* spl */
|
|
|
|
|
"", /* sph */
|
|
|
|
|
"pmc",
|
|
|
|
|
"mem",
|
|
|
|
|
|
|
|
|
|
"pc",
|
|
|
|
|
"sp",
|
|
|
|
|
|
|
|
|
|
"x",
|
|
|
|
|
"a",
|
|
|
|
|
"c",
|
|
|
|
|
"b",
|
|
|
|
|
"e",
|
|
|
|
|
"d",
|
|
|
|
|
"l",
|
|
|
|
|
"h",
|
|
|
|
|
|
|
|
|
|
"ax",
|
|
|
|
|
"bc",
|
|
|
|
|
"de",
|
|
|
|
|
"hl",
|
|
|
|
|
|
|
|
|
|
"bank0_r0",
|
|
|
|
|
"bank0_r1",
|
|
|
|
|
"bank0_r2",
|
|
|
|
|
"bank0_r3",
|
|
|
|
|
"bank0_r4",
|
|
|
|
|
"bank0_r5",
|
|
|
|
|
"bank0_r6",
|
|
|
|
|
"bank0_r7",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"bank0_rp0",
|
|
|
|
|
"bank0_rp1",
|
|
|
|
|
"bank0_rp2",
|
|
|
|
|
"bank0_rp3",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
"",
|
|
|
|
|
"",
|
|
|
|
|
"",
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
"",
|
|
|
|
|
|
|
|
|
|
/* The 16 register slots would be named
|
|
|
|
|
bank0_rp0_ptr_regnum ... bank3_rp3_ptr_regnum, but we don't
|
|
|
|
|
want these to be user visible registers. */
|
|
|
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""
|
2014-02-18 03:03:23 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return reg_names[regnr];
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
/* Implement the "register_reggroup_p" gdbarch method. */
|
2012-02-04 14:05:50 +08:00
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
static int
|
|
|
|
|
rl78_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
|
|
|
|
|
struct reggroup *group)
|
|
|
|
|
{
|
|
|
|
|
if (group == all_reggroup)
|
|
|
|
|
return 1;
|
2012-02-04 14:05:50 +08:00
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
/* All other registers are saved and restored. */
|
|
|
|
|
if (group == save_reggroup || group == restore_reggroup)
|
|
|
|
|
{
|
2013-05-04 14:14:53 +08:00
|
|
|
if ((regnum < RL78_NUM_REGS
|
2013-08-16 12:30:23 +08:00
|
|
|
&& regnum != RL78_SPL_REGNUM
|
|
|
|
|
&& regnum != RL78_SPH_REGNUM
|
|
|
|
|
&& regnum != RL78_RAW_PC_REGNUM)
|
|
|
|
|
|| regnum == RL78_SP_REGNUM
|
|
|
|
|
|| regnum == RL78_PC_REGNUM)
|
2012-02-15 04:15:44 +08:00
|
|
|
return 1;
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((RL78_BANK0_R0_REGNUM <= regnum && regnum <= RL78_BANK3_R7_REGNUM)
|
|
|
|
|
|| regnum == RL78_ES_REGNUM
|
|
|
|
|
|| regnum == RL78_CS_REGNUM
|
|
|
|
|
|| regnum == RL78_SPL_REGNUM
|
|
|
|
|
|| regnum == RL78_SPH_REGNUM
|
|
|
|
|
|| regnum == RL78_PMC_REGNUM
|
|
|
|
|
|| regnum == RL78_MEM_REGNUM
|
2013-08-16 12:30:23 +08:00
|
|
|
|| regnum == RL78_RAW_PC_REGNUM
|
2012-02-15 04:15:44 +08:00
|
|
|
|| (RL78_BANK0_RP0_REGNUM <= regnum && regnum <= RL78_BANK3_RP3_REGNUM))
|
|
|
|
|
return group == system_reggroup;
|
|
|
|
|
|
|
|
|
|
return group == general_reggroup;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Strip bits to form an instruction address. (When fetching a
|
|
|
|
|
32-bit address from the stack, the high eight bits are garbage.
|
|
|
|
|
This function strips off those unused bits.) */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_make_instruction_address (CORE_ADDR addr)
|
|
|
|
|
{
|
|
|
|
|
return addr & 0xffffff;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set / clear bits necessary to make a data address. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_make_data_address (CORE_ADDR addr)
|
|
|
|
|
{
|
|
|
|
|
return (addr & 0xffff) | 0xf0000;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "pseudo_register_read" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static enum register_status
|
|
|
|
|
rl78_pseudo_register_read (struct gdbarch *gdbarch,
|
|
|
|
|
struct regcache *regcache,
|
|
|
|
|
int reg, gdb_byte *buffer)
|
|
|
|
|
{
|
|
|
|
|
enum register_status status;
|
|
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
if (RL78_BANK0_R0_REGNUM <= reg && reg <= RL78_BANK3_R7_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
int raw_regnum = RL78_RAW_BANK0_R0_REGNUM
|
|
|
|
|
+ (reg - RL78_BANK0_R0_REGNUM);
|
|
|
|
|
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum, buffer);
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_BANK0_RP0_REGNUM <= reg && reg <= RL78_BANK3_RP3_REGNUM)
|
2012-02-04 14:05:50 +08:00
|
|
|
{
|
|
|
|
|
int raw_regnum = 2 * (reg - RL78_BANK0_RP0_REGNUM)
|
2012-02-15 04:15:44 +08:00
|
|
|
+ RL78_RAW_BANK0_R0_REGNUM;
|
2012-02-04 14:05:50 +08:00
|
|
|
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
status = regcache_raw_read (regcache, raw_regnum, buffer);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum + 1, buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_BANK0_RP0_PTR_REGNUM <= reg && reg <= RL78_BANK3_RP3_PTR_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
int raw_regnum = 2 * (reg - RL78_BANK0_RP0_PTR_REGNUM)
|
|
|
|
|
+ RL78_RAW_BANK0_R0_REGNUM;
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
status = regcache_raw_read (regcache, raw_regnum, buffer);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum + 1, buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
else if (reg == RL78_SP_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
status = regcache_raw_read (regcache, RL78_SPL_REGNUM, buffer);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
status = regcache_raw_read (regcache, RL78_SPH_REGNUM, buffer + 1);
|
|
|
|
|
}
|
2013-08-16 12:30:23 +08:00
|
|
|
else if (reg == RL78_PC_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
gdb_byte rawbuf[4];
|
|
|
|
|
|
|
|
|
|
status = regcache_raw_read (regcache, RL78_RAW_PC_REGNUM, rawbuf);
|
|
|
|
|
memcpy (buffer, rawbuf, 3);
|
|
|
|
|
}
|
2012-02-04 14:05:50 +08:00
|
|
|
else if (RL78_X_REGNUM <= reg && reg <= RL78_H_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST psw;
|
|
|
|
|
|
|
|
|
|
status = regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
{
|
|
|
|
|
/* RSB0 is at bit 3; RSBS1 is at bit 5. */
|
|
|
|
|
int bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
|
2012-02-15 04:15:44 +08:00
|
|
|
int raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
|
2012-02-04 14:05:50 +08:00
|
|
|
+ (reg - RL78_X_REGNUM);
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum, buffer);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_AX_REGNUM <= reg && reg <= RL78_HL_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST psw;
|
|
|
|
|
|
|
|
|
|
status = regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
{
|
|
|
|
|
/* RSB0 is at bit 3; RSBS1 is at bit 5. */
|
|
|
|
|
int bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
|
2012-02-15 04:15:44 +08:00
|
|
|
int raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
|
2012-02-04 14:05:50 +08:00
|
|
|
+ 2 * (reg - RL78_AX_REGNUM);
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum, buffer);
|
|
|
|
|
if (status == REG_VALID)
|
|
|
|
|
status = regcache_raw_read (regcache, raw_regnum + 1,
|
|
|
|
|
buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
gdb_assert_not_reached ("invalid pseudo register number");
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "pseudo_register_write" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rl78_pseudo_register_write (struct gdbarch *gdbarch,
|
|
|
|
|
struct regcache *regcache,
|
|
|
|
|
int reg, const gdb_byte *buffer)
|
|
|
|
|
{
|
2012-02-15 04:15:44 +08:00
|
|
|
if (RL78_BANK0_R0_REGNUM <= reg && reg <= RL78_BANK3_R7_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
int raw_regnum = RL78_RAW_BANK0_R0_REGNUM
|
|
|
|
|
+ (reg - RL78_BANK0_R0_REGNUM);
|
|
|
|
|
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum, buffer);
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_BANK0_RP0_REGNUM <= reg && reg <= RL78_BANK3_RP3_REGNUM)
|
2012-02-04 14:05:50 +08:00
|
|
|
{
|
|
|
|
|
int raw_regnum = 2 * (reg - RL78_BANK0_RP0_REGNUM)
|
2012-02-15 04:15:44 +08:00
|
|
|
+ RL78_RAW_BANK0_R0_REGNUM;
|
2012-02-04 14:05:50 +08:00
|
|
|
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
regcache_raw_write (regcache, raw_regnum, buffer);
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum + 1, buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_BANK0_RP0_PTR_REGNUM <= reg && reg <= RL78_BANK3_RP3_PTR_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
int raw_regnum = 2 * (reg - RL78_BANK0_RP0_PTR_REGNUM)
|
|
|
|
|
+ RL78_RAW_BANK0_R0_REGNUM;
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
regcache_raw_write (regcache, raw_regnum, buffer);
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum + 1, buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
else if (reg == RL78_SP_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
regcache_raw_write (regcache, RL78_SPL_REGNUM, buffer);
|
|
|
|
|
regcache_raw_write (regcache, RL78_SPH_REGNUM, buffer + 1);
|
|
|
|
|
}
|
2013-08-16 12:30:23 +08:00
|
|
|
else if (reg == RL78_PC_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
gdb_byte rawbuf[4];
|
|
|
|
|
|
|
|
|
|
memcpy (rawbuf, buffer, 3);
|
|
|
|
|
rawbuf[3] = 0;
|
|
|
|
|
regcache_raw_write (regcache, RL78_RAW_PC_REGNUM, rawbuf);
|
|
|
|
|
}
|
2012-02-04 14:05:50 +08:00
|
|
|
else if (RL78_X_REGNUM <= reg && reg <= RL78_H_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST psw;
|
|
|
|
|
int bank;
|
|
|
|
|
int raw_regnum;
|
|
|
|
|
|
|
|
|
|
regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
|
|
|
|
|
bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
|
|
|
|
|
/* RSB0 is at bit 3; RSBS1 is at bit 5. */
|
2012-02-15 04:15:44 +08:00
|
|
|
raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
|
2012-02-04 14:05:50 +08:00
|
|
|
+ (reg - RL78_X_REGNUM);
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum, buffer);
|
|
|
|
|
}
|
|
|
|
|
else if (RL78_AX_REGNUM <= reg && reg <= RL78_HL_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST psw;
|
|
|
|
|
int bank, raw_regnum;
|
|
|
|
|
|
|
|
|
|
regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
|
|
|
|
|
bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
|
|
|
|
|
/* RSB0 is at bit 3; RSBS1 is at bit 5. */
|
2012-02-15 04:15:44 +08:00
|
|
|
raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
|
2012-02-04 14:05:50 +08:00
|
|
|
+ 2 * (reg - RL78_AX_REGNUM);
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum, buffer);
|
|
|
|
|
regcache_raw_write (regcache, raw_regnum + 1, buffer + 1);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
gdb_assert_not_reached ("invalid pseudo register number");
|
|
|
|
|
}
|
|
|
|
|
|
2016-11-03 22:35:13 +08:00
|
|
|
/* The documented BRK instruction is actually a two byte sequence,
|
|
|
|
|
{0x61, 0xcc}, but instructions may be as short as one byte.
|
|
|
|
|
Correspondence with Renesas revealed that the one byte sequence
|
|
|
|
|
0xff is used when a one byte breakpoint instruction is required. */
|
2016-11-03 22:35:14 +08:00
|
|
|
constexpr gdb_byte rl78_break_insn[] = { 0xff };
|
2012-02-04 14:05:50 +08:00
|
|
|
|
2016-11-03 22:35:14 +08:00
|
|
|
typedef BP_MANIPULATION (rl78_break_insn) rl78_breakpoint;
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
/* Define a "handle" struct for fetching the next opcode. */
|
|
|
|
|
|
|
|
|
|
struct rl78_get_opcode_byte_handle
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR pc;
|
|
|
|
|
};
|
|
|
|
|
|
2015-04-21 14:37:44 +08:00
|
|
|
static int
|
|
|
|
|
opc_reg_to_gdb_regnum (int opcreg)
|
|
|
|
|
{
|
|
|
|
|
switch (opcreg)
|
|
|
|
|
{
|
|
|
|
|
case RL78_Reg_X:
|
|
|
|
|
return RL78_X_REGNUM;
|
|
|
|
|
case RL78_Reg_A:
|
|
|
|
|
return RL78_A_REGNUM;
|
|
|
|
|
case RL78_Reg_C:
|
|
|
|
|
return RL78_C_REGNUM;
|
|
|
|
|
case RL78_Reg_B:
|
|
|
|
|
return RL78_B_REGNUM;
|
|
|
|
|
case RL78_Reg_E:
|
|
|
|
|
return RL78_E_REGNUM;
|
|
|
|
|
case RL78_Reg_D:
|
|
|
|
|
return RL78_D_REGNUM;
|
|
|
|
|
case RL78_Reg_L:
|
|
|
|
|
return RL78_L_REGNUM;
|
|
|
|
|
case RL78_Reg_H:
|
|
|
|
|
return RL78_H_REGNUM;
|
|
|
|
|
case RL78_Reg_AX:
|
|
|
|
|
return RL78_AX_REGNUM;
|
|
|
|
|
case RL78_Reg_BC:
|
|
|
|
|
return RL78_BC_REGNUM;
|
|
|
|
|
case RL78_Reg_DE:
|
|
|
|
|
return RL78_DE_REGNUM;
|
|
|
|
|
case RL78_Reg_HL:
|
|
|
|
|
return RL78_HL_REGNUM;
|
|
|
|
|
case RL78_Reg_SP:
|
|
|
|
|
return RL78_SP_REGNUM;
|
|
|
|
|
case RL78_Reg_PSW:
|
|
|
|
|
return RL78_PSW_REGNUM;
|
|
|
|
|
case RL78_Reg_CS:
|
|
|
|
|
return RL78_CS_REGNUM;
|
|
|
|
|
case RL78_Reg_ES:
|
|
|
|
|
return RL78_ES_REGNUM;
|
|
|
|
|
case RL78_Reg_PMC:
|
|
|
|
|
return RL78_PMC_REGNUM;
|
|
|
|
|
case RL78_Reg_MEM:
|
|
|
|
|
return RL78_MEM_REGNUM;
|
|
|
|
|
default:
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("Undefined mapping for opc reg %d"),
|
|
|
|
|
opcreg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not reached. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
/* Fetch a byte on behalf of the opcode decoder. HANDLE contains
|
|
|
|
|
the memory address of the next byte to fetch. If successful,
|
|
|
|
|
the address in the handle is updated and the byte fetched is
|
|
|
|
|
returned as the value of the function. If not successful, -1
|
|
|
|
|
is returned. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
rl78_get_opcode_byte (void *handle)
|
|
|
|
|
{
|
2015-09-26 02:08:07 +08:00
|
|
|
struct rl78_get_opcode_byte_handle *opcdata
|
|
|
|
|
= (struct rl78_get_opcode_byte_handle *) handle;
|
2012-02-04 14:05:50 +08:00
|
|
|
int status;
|
|
|
|
|
gdb_byte byte;
|
|
|
|
|
|
|
|
|
|
status = target_read_memory (opcdata->pc, &byte, 1);
|
|
|
|
|
if (status == 0)
|
|
|
|
|
{
|
|
|
|
|
opcdata->pc += 1;
|
|
|
|
|
return byte;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function for finding saved registers in a 'struct pv_area'; this
|
|
|
|
|
function is passed to pv_area_scan.
|
|
|
|
|
|
|
|
|
|
If VALUE is a saved register, ADDR says it was saved at a constant
|
|
|
|
|
offset from the frame base, and SIZE indicates that the whole
|
|
|
|
|
register was saved, record its offset. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size,
|
|
|
|
|
pv_t value)
|
|
|
|
|
{
|
|
|
|
|
struct rl78_prologue *result = (struct rl78_prologue *) result_untyped;
|
|
|
|
|
|
|
|
|
|
if (value.kind == pvk_register
|
|
|
|
|
&& value.k == 0
|
|
|
|
|
&& pv_is_register (addr, RL78_SP_REGNUM)
|
* gdbarch.sh (target_gdbarch): Remove macro.
(get_target_gdbarch): Rename to target_gdbarch.
* gdbarch.c, gdbarch.h: Rebuild.
* ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
procfs.c, progspace.c, ravenscar-thread.c, record.c,
remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
target-descriptions.c, target.c, target.h, tracepoint.c,
windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
python/py-inferior.c, python/python.c: Update.
2012-11-10 03:58:03 +08:00
|
|
|
&& size == register_size (target_gdbarch (), value.reg))
|
2012-02-04 14:05:50 +08:00
|
|
|
result->reg_offset[value.reg] = addr.k;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Analyze a prologue starting at START_PC, going no further than
|
|
|
|
|
LIMIT_PC. Fill in RESULT as appropriate. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rl78_analyze_prologue (CORE_ADDR start_pc,
|
|
|
|
|
CORE_ADDR limit_pc, struct rl78_prologue *result)
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR pc, next_pc;
|
|
|
|
|
int rn;
|
|
|
|
|
pv_t reg[RL78_NUM_TOTAL_REGS];
|
|
|
|
|
struct pv_area *stack;
|
|
|
|
|
struct cleanup *back_to;
|
|
|
|
|
CORE_ADDR after_last_frame_setup_insn = start_pc;
|
|
|
|
|
int bank = 0;
|
|
|
|
|
|
|
|
|
|
memset (result, 0, sizeof (*result));
|
|
|
|
|
|
|
|
|
|
for (rn = 0; rn < RL78_NUM_TOTAL_REGS; rn++)
|
|
|
|
|
{
|
|
|
|
|
reg[rn] = pv_register (rn, 0);
|
|
|
|
|
result->reg_offset[rn] = 1;
|
|
|
|
|
}
|
|
|
|
|
|
* gdbarch.sh (target_gdbarch): Remove macro.
(get_target_gdbarch): Rename to target_gdbarch.
* gdbarch.c, gdbarch.h: Rebuild.
* ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
procfs.c, progspace.c, ravenscar-thread.c, record.c,
remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
target-descriptions.c, target.c, target.h, tracepoint.c,
windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
python/py-inferior.c, python/python.c: Update.
2012-11-10 03:58:03 +08:00
|
|
|
stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
|
2012-02-04 14:05:50 +08:00
|
|
|
back_to = make_cleanup_free_pv_area (stack);
|
|
|
|
|
|
|
|
|
|
/* The call instruction has saved the return address on the stack. */
|
|
|
|
|
reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -4);
|
|
|
|
|
pv_area_store (stack, reg[RL78_SP_REGNUM], 4, reg[RL78_PC_REGNUM]);
|
|
|
|
|
|
|
|
|
|
pc = start_pc;
|
|
|
|
|
while (pc < limit_pc)
|
|
|
|
|
{
|
|
|
|
|
int bytes_read;
|
|
|
|
|
struct rl78_get_opcode_byte_handle opcode_handle;
|
|
|
|
|
RL78_Opcode_Decoded opc;
|
|
|
|
|
|
|
|
|
|
opcode_handle.pc = pc;
|
|
|
|
|
bytes_read = rl78_decode_opcode (pc, &opc, rl78_get_opcode_byte,
|
2015-05-01 03:25:49 +08:00
|
|
|
&opcode_handle, RL78_ISA_DEFAULT);
|
2012-02-04 14:05:50 +08:00
|
|
|
next_pc = pc + bytes_read;
|
|
|
|
|
|
|
|
|
|
if (opc.id == RLO_sel)
|
|
|
|
|
{
|
|
|
|
|
bank = opc.op[1].addend;
|
|
|
|
|
}
|
|
|
|
|
else if (opc.id == RLO_mov
|
|
|
|
|
&& opc.op[0].type == RL78_Operand_PreDec
|
|
|
|
|
&& opc.op[0].reg == RL78_Reg_SP
|
|
|
|
|
&& opc.op[1].type == RL78_Operand_Register)
|
|
|
|
|
{
|
|
|
|
|
int rsrc = (bank * RL78_REGS_PER_BANK)
|
|
|
|
|
+ 2 * (opc.op[1].reg - RL78_Reg_AX);
|
|
|
|
|
|
|
|
|
|
reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -1);
|
|
|
|
|
pv_area_store (stack, reg[RL78_SP_REGNUM], 1, reg[rsrc]);
|
|
|
|
|
reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -1);
|
|
|
|
|
pv_area_store (stack, reg[RL78_SP_REGNUM], 1, reg[rsrc + 1]);
|
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
|
}
|
|
|
|
|
else if (opc.id == RLO_sub
|
|
|
|
|
&& opc.op[0].type == RL78_Operand_Register
|
|
|
|
|
&& opc.op[0].reg == RL78_Reg_SP
|
|
|
|
|
&& opc.op[1].type == RL78_Operand_Immediate)
|
|
|
|
|
{
|
|
|
|
|
int addend = opc.op[1].addend;
|
|
|
|
|
|
|
|
|
|
reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM],
|
|
|
|
|
-addend);
|
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
|
}
|
2015-04-21 14:37:44 +08:00
|
|
|
else if (opc.id == RLO_mov
|
|
|
|
|
&& opc.size == RL78_Word
|
|
|
|
|
&& opc.op[0].type == RL78_Operand_Register
|
|
|
|
|
&& opc.op[1].type == RL78_Operand_Indirect
|
|
|
|
|
&& opc.op[1].addend == RL78_SP_ADDR)
|
|
|
|
|
{
|
|
|
|
|
reg[opc_reg_to_gdb_regnum (opc.op[0].reg)]
|
|
|
|
|
= reg[RL78_SP_REGNUM];
|
|
|
|
|
}
|
|
|
|
|
else if (opc.id == RLO_sub
|
|
|
|
|
&& opc.size == RL78_Word
|
|
|
|
|
&& opc.op[0].type == RL78_Operand_Register
|
|
|
|
|
&& opc.op[1].type == RL78_Operand_Immediate)
|
|
|
|
|
{
|
|
|
|
|
int addend = opc.op[1].addend;
|
|
|
|
|
int regnum = opc_reg_to_gdb_regnum (opc.op[0].reg);
|
|
|
|
|
|
|
|
|
|
reg[regnum] = pv_add_constant (reg[regnum], -addend);
|
|
|
|
|
}
|
|
|
|
|
else if (opc.id == RLO_mov
|
|
|
|
|
&& opc.size == RL78_Word
|
|
|
|
|
&& opc.op[0].type == RL78_Operand_Indirect
|
|
|
|
|
&& opc.op[0].addend == RL78_SP_ADDR
|
|
|
|
|
&& opc.op[1].type == RL78_Operand_Register)
|
|
|
|
|
{
|
|
|
|
|
reg[RL78_SP_REGNUM]
|
|
|
|
|
= reg[opc_reg_to_gdb_regnum (opc.op[1].reg)];
|
|
|
|
|
after_last_frame_setup_insn = next_pc;
|
|
|
|
|
}
|
2012-02-04 14:05:50 +08:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Terminate the prologue scan. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pc = next_pc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Is the frame size (offset, really) a known constant? */
|
|
|
|
|
if (pv_is_register (reg[RL78_SP_REGNUM], RL78_SP_REGNUM))
|
|
|
|
|
result->frame_size = reg[RL78_SP_REGNUM].k;
|
|
|
|
|
|
|
|
|
|
/* Record where all the registers were saved. */
|
|
|
|
|
pv_area_scan (stack, check_for_saved, (void *) result);
|
|
|
|
|
|
|
|
|
|
result->prologue_end = after_last_frame_setup_insn;
|
|
|
|
|
|
|
|
|
|
do_cleanups (back_to);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "addr_bits_remove" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
|
|
|
|
|
{
|
|
|
|
|
return addr & 0xffffff;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "address_to_pointer" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rl78_address_to_pointer (struct gdbarch *gdbarch,
|
|
|
|
|
struct type *type, gdb_byte *buf, CORE_ADDR addr)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
|
|
|
|
|
store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
|
|
|
|
|
addr & 0xffffff);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "pointer_to_address" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_pointer_to_address (struct gdbarch *gdbarch,
|
|
|
|
|
struct type *type, const gdb_byte *buf)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
CORE_ADDR addr
|
|
|
|
|
= extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
|
|
|
|
|
|
|
|
|
|
/* Is it a code address? */
|
|
|
|
|
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
|
|
|
|
|
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
|
|
|
|
|
|| TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))
|
|
|
|
|
|| TYPE_LENGTH (type) == 4)
|
|
|
|
|
return rl78_make_instruction_address (addr);
|
|
|
|
|
else
|
|
|
|
|
return rl78_make_data_address (addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "skip_prologue" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
|
|
|
|
{
|
2012-02-15 04:07:26 +08:00
|
|
|
const char *name;
|
2012-02-04 14:05:50 +08:00
|
|
|
CORE_ADDR func_addr, func_end;
|
|
|
|
|
struct rl78_prologue p;
|
|
|
|
|
|
|
|
|
|
/* Try to find the extent of the function that contains PC. */
|
|
|
|
|
if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
|
|
|
|
|
return pc;
|
|
|
|
|
|
|
|
|
|
rl78_analyze_prologue (pc, func_end, &p);
|
|
|
|
|
return p.prologue_end;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "unwind_pc" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
|
|
|
|
|
{
|
|
|
|
|
return rl78_addr_bits_remove
|
|
|
|
|
(arch, frame_unwind_register_unsigned (next_frame,
|
|
|
|
|
RL78_PC_REGNUM));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "unwind_sp" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
|
|
|
|
|
{
|
|
|
|
|
return frame_unwind_register_unsigned (next_frame, RL78_SP_REGNUM);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Given a frame described by THIS_FRAME, decode the prologue of its
|
|
|
|
|
associated function if there is not cache entry as specified by
|
|
|
|
|
THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
|
|
|
|
|
return that struct as the value of this function. */
|
|
|
|
|
|
|
|
|
|
static struct rl78_prologue *
|
|
|
|
|
rl78_analyze_frame_prologue (struct frame_info *this_frame,
|
|
|
|
|
void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
if (!*this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR func_start, stop_addr;
|
|
|
|
|
|
|
|
|
|
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rl78_prologue);
|
|
|
|
|
|
|
|
|
|
func_start = get_frame_func (this_frame);
|
|
|
|
|
stop_addr = get_frame_pc (this_frame);
|
|
|
|
|
|
|
|
|
|
/* If we couldn't find any function containing the PC, then
|
|
|
|
|
just initialize the prologue cache, but don't do anything. */
|
|
|
|
|
if (!func_start)
|
|
|
|
|
stop_addr = func_start;
|
|
|
|
|
|
2015-09-26 02:08:07 +08:00
|
|
|
rl78_analyze_prologue (func_start, stop_addr,
|
|
|
|
|
(struct rl78_prologue *) *this_prologue_cache);
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
|
2015-09-26 02:08:07 +08:00
|
|
|
return (struct rl78_prologue *) *this_prologue_cache;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Given a frame and a prologue cache, return this frame's base. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
struct rl78_prologue *p
|
|
|
|
|
= rl78_analyze_frame_prologue (this_frame, this_prologue_cache);
|
|
|
|
|
CORE_ADDR sp = get_frame_register_unsigned (this_frame, RL78_SP_REGNUM);
|
|
|
|
|
|
|
|
|
|
return rl78_make_data_address (sp - p->frame_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "frame_this_id" method for unwinding frames. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rl78_this_id (struct frame_info *this_frame,
|
|
|
|
|
void **this_prologue_cache, struct frame_id *this_id)
|
|
|
|
|
{
|
|
|
|
|
*this_id = frame_id_build (rl78_frame_base (this_frame,
|
|
|
|
|
this_prologue_cache),
|
|
|
|
|
get_frame_func (this_frame));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implement the "frame_prev_register" method for unwinding frames. */
|
|
|
|
|
|
|
|
|
|
static struct value *
|
|
|
|
|
rl78_prev_register (struct frame_info *this_frame,
|
|
|
|
|
void **this_prologue_cache, int regnum)
|
|
|
|
|
{
|
|
|
|
|
struct rl78_prologue *p
|
|
|
|
|
= rl78_analyze_frame_prologue (this_frame, this_prologue_cache);
|
|
|
|
|
CORE_ADDR frame_base = rl78_frame_base (this_frame, this_prologue_cache);
|
|
|
|
|
|
|
|
|
|
if (regnum == RL78_SP_REGNUM)
|
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum, frame_base);
|
|
|
|
|
|
|
|
|
|
else if (regnum == RL78_SPL_REGNUM)
|
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum,
|
|
|
|
|
(frame_base & 0xff));
|
|
|
|
|
|
|
|
|
|
else if (regnum == RL78_SPH_REGNUM)
|
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum,
|
|
|
|
|
((frame_base >> 8) & 0xff));
|
|
|
|
|
|
|
|
|
|
/* If prologue analysis says we saved this register somewhere,
|
|
|
|
|
return a description of the stack slot holding it. */
|
|
|
|
|
else if (p->reg_offset[regnum] != 1)
|
|
|
|
|
{
|
|
|
|
|
struct value *rv =
|
|
|
|
|
frame_unwind_got_memory (this_frame, regnum,
|
|
|
|
|
frame_base + p->reg_offset[regnum]);
|
|
|
|
|
|
|
|
|
|
if (regnum == RL78_PC_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST pc = rl78_make_instruction_address (value_as_long (rv));
|
|
|
|
|
|
|
|
|
|
return frame_unwind_got_constant (this_frame, regnum, pc);
|
|
|
|
|
}
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, presume we haven't changed the value of this
|
|
|
|
|
register, and get it from the next frame. */
|
|
|
|
|
else
|
|
|
|
|
return frame_unwind_got_register (this_frame, regnum, regnum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct frame_unwind rl78_unwind =
|
|
|
|
|
{
|
|
|
|
|
NORMAL_FRAME,
|
|
|
|
|
default_frame_unwind_stop_reason,
|
|
|
|
|
rl78_this_id,
|
|
|
|
|
rl78_prev_register,
|
|
|
|
|
NULL,
|
|
|
|
|
default_frame_sniffer
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Implement the "dwarf_reg_to_regnum" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
rl78_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
|
|
|
|
|
{
|
|
|
|
|
if (0 <= reg && reg <= 31)
|
|
|
|
|
{
|
|
|
|
|
if ((reg & 1) == 0)
|
Use 16-bit integer type for rl78 register pairs.
This patch changes rl78-tdep.c so that a 16-bit type is used for
register pairs instead of a pointer type as was previously the case.
This will cause these register pairs to be displayed as integers
instead of as a data address with a 0xf0000 ORed in.
E.g. registers ax, bc, de, and hl might now be displayed like this:
(gdb) info registers ax bc de hl
ax 0x6 6
bc 0x0 0
de 0x10c3 4291
hl 0x108d 423
Whereas, before, they were displayed as follows:
(gdb) info registers ax bc de hl
ax 0xf0006 0xf0006
bc 0xf0000 0xf0000
de 0xf10c3 0xf10c3
hl 0xf108d 0xf108d
These pairs are 16 bit quantities and should be displayed as such.
This change also affects the way that the banked register pairs are
displayed. Within GDB, the banked register pairs are named bank0_rp0,
bank0_rp1, .., bank3_rp2, bank3_rp3.
However, these register pairs need to be used as addresses in DWARF
expressions. I have added 16 pseudo registers corresponding to banked
register pairs. These new pseudo registers are all hidden from the
user and have a pointer type. Values from these registers are
intended to be used in DWARF expressions. Therefore,
rl78_dwarf_reg_to_regnum() has been adjusted to return these new
pseudo register numbers.
I had a much simpler patch which only changed the types, but it showed
a number of regressions due to integer values from the banked register
pairs being used as part of an address expression. This current patch
shows no regressions and now displays values of register pairs
correctly.
* rl78-tdep.c ( RL78_BANK0_RP0_PTR_REGNUM, RL78_BANK0_RP1_PTR_REGNUM)
(RL78_BANK0_RP2_PTR_REGNUM, RL78_BANK0_RP3_PTR_REGNUM)
(RL78_BANK1_RP0_PTR_REGNUM, RL78_BANK1_RP1_PTR_REGNUM)
(RL78_BANK1_RP2_PTR_REGNUM, RL78_BANK1_RP3_PTR_REGNUM)
(RL78_BANK2_RP0_PTR_REGNUM, RL78_BANK2_RP1_PTR_REGNUM)
(RL78_BANK2_RP2_PTR_REGNUM, RL78_BANK2_RP3_PTR_REGNUM)
(RL78_BANK3_RP0_PTR_REGNUM, RL78_BANK3_RP1_PTR_REGNUM)
(RL78_BANK3_RP2_PTR_REGNUM, RL78_BANK3_RP3_PTR_REGNUM):
New constants.
(rl78_register_type): Use a data pointer type for SP and
new pseudo registers mentioned above. Use a 16 bit integer
type for all other register pairs.
(rl78_register_name, rl78_g10_register_name): Update for
new pseudo registers.
(rl78_pseudo_register_read): Likewise.
(rl78_pseudo_register_write): Likewise.
(rl78_dwarf_reg_to_regnum): Return register numbers representing
to the newly added pseudo registers.
2014-02-25 15:32:45 +08:00
|
|
|
/* Map even registers to their 16-bit counterparts which have a
|
|
|
|
|
pointer type. This is usually what is required from the DWARF
|
|
|
|
|
info. */
|
|
|
|
|
return (reg >> 1) + RL78_BANK0_RP0_PTR_REGNUM;
|
2012-02-04 14:05:50 +08:00
|
|
|
else
|
|
|
|
|
return reg;
|
|
|
|
|
}
|
|
|
|
|
else if (reg == 32)
|
|
|
|
|
return RL78_SP_REGNUM;
|
|
|
|
|
else if (reg == 33)
|
2013-05-04 14:14:53 +08:00
|
|
|
return -1; /* ap */
|
|
|
|
|
else if (reg == 34)
|
|
|
|
|
return RL78_PSW_REGNUM;
|
|
|
|
|
else if (reg == 35)
|
|
|
|
|
return RL78_ES_REGNUM;
|
|
|
|
|
else if (reg == 36)
|
|
|
|
|
return RL78_CS_REGNUM;
|
|
|
|
|
else if (reg == 37)
|
2012-02-04 14:05:50 +08:00
|
|
|
return RL78_PC_REGNUM;
|
|
|
|
|
else
|
2015-10-27 07:05:21 +08:00
|
|
|
return -1;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
|
2012-02-15 04:15:44 +08:00
|
|
|
/* Implement the `register_sim_regno' gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
rl78_register_sim_regno (struct gdbarch *gdbarch, int regnum)
|
|
|
|
|
{
|
|
|
|
|
gdb_assert (regnum < RL78_NUM_REGS);
|
|
|
|
|
|
|
|
|
|
/* So long as regnum is in [0, RL78_NUM_REGS), it's valid. We
|
|
|
|
|
just want to override the default here which disallows register
|
|
|
|
|
numbers which have no names. */
|
|
|
|
|
return regnum;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
/* Implement the "return_value" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static enum return_value_convention
|
|
|
|
|
rl78_return_value (struct gdbarch *gdbarch,
|
2012-05-16 22:35:09 +08:00
|
|
|
struct value *function,
|
2012-02-04 14:05:50 +08:00
|
|
|
struct type *valtype,
|
|
|
|
|
struct regcache *regcache,
|
|
|
|
|
gdb_byte *readbuf, const gdb_byte *writebuf)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
ULONGEST valtype_len = TYPE_LENGTH (valtype);
|
2014-02-18 03:03:23 +08:00
|
|
|
int is_g10 = gdbarch_tdep (gdbarch)->elf_flags & E_FLAG_RL78_G10;
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
if (valtype_len > 8)
|
|
|
|
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
|
|
|
|
|
|
|
|
|
if (readbuf)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST u;
|
2012-02-15 04:15:44 +08:00
|
|
|
int argreg = RL78_RAW_BANK1_R0_REGNUM;
|
2014-02-18 03:03:23 +08:00
|
|
|
CORE_ADDR g10_raddr = 0xffec8;
|
2012-02-04 14:05:50 +08:00
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
|
|
while (valtype_len > 0)
|
|
|
|
|
{
|
2014-02-18 03:03:23 +08:00
|
|
|
if (is_g10)
|
|
|
|
|
u = read_memory_integer (g10_raddr, 1,
|
|
|
|
|
gdbarch_byte_order (gdbarch));
|
|
|
|
|
else
|
|
|
|
|
regcache_cooked_read_unsigned (regcache, argreg, &u);
|
2012-02-04 14:05:50 +08:00
|
|
|
store_unsigned_integer (readbuf + offset, 1, byte_order, u);
|
|
|
|
|
valtype_len -= 1;
|
|
|
|
|
offset += 1;
|
|
|
|
|
argreg++;
|
2014-02-18 03:03:23 +08:00
|
|
|
g10_raddr++;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (writebuf)
|
|
|
|
|
{
|
|
|
|
|
ULONGEST u;
|
2012-02-15 04:15:44 +08:00
|
|
|
int argreg = RL78_RAW_BANK1_R0_REGNUM;
|
2014-02-18 03:03:23 +08:00
|
|
|
CORE_ADDR g10_raddr = 0xffec8;
|
2012-02-04 14:05:50 +08:00
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
|
|
while (valtype_len > 0)
|
|
|
|
|
{
|
|
|
|
|
u = extract_unsigned_integer (writebuf + offset, 1, byte_order);
|
2014-02-18 03:03:23 +08:00
|
|
|
if (is_g10) {
|
|
|
|
|
gdb_byte b = u & 0xff;
|
|
|
|
|
write_memory (g10_raddr, &b, 1);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, argreg, u);
|
2012-02-04 14:05:50 +08:00
|
|
|
valtype_len -= 1;
|
|
|
|
|
offset += 1;
|
|
|
|
|
argreg++;
|
2014-02-18 03:03:23 +08:00
|
|
|
g10_raddr++;
|
2012-02-04 14:05:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Implement the "frame_align" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
|
|
|
|
|
{
|
|
|
|
|
return rl78_make_data_address (align_down (sp, 2));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Implement the "dummy_id" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static struct frame_id
|
|
|
|
|
rl78_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
|
|
|
|
|
{
|
|
|
|
|
return
|
|
|
|
|
frame_id_build (rl78_make_data_address
|
|
|
|
|
(get_frame_register_unsigned
|
|
|
|
|
(this_frame, RL78_SP_REGNUM)),
|
|
|
|
|
get_frame_pc (this_frame));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Implement the "push_dummy_call" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
rl78_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
|
|
|
|
struct regcache *regcache, CORE_ADDR bp_addr,
|
|
|
|
|
int nargs, struct value **args, CORE_ADDR sp,
|
|
|
|
|
int struct_return, CORE_ADDR struct_addr)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
gdb_byte buf[4];
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Push arguments in reverse order. */
|
|
|
|
|
for (i = nargs - 1; i >= 0; i--)
|
|
|
|
|
{
|
|
|
|
|
struct type *value_type = value_enclosing_type (args[i]);
|
|
|
|
|
int len = TYPE_LENGTH (value_type);
|
|
|
|
|
int container_len = (len + 1) & ~1;
|
|
|
|
|
|
|
|
|
|
sp -= container_len;
|
|
|
|
|
write_memory (rl78_make_data_address (sp),
|
|
|
|
|
value_contents_all (args[i]), len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Store struct value address. */
|
|
|
|
|
if (struct_return)
|
|
|
|
|
{
|
|
|
|
|
store_unsigned_integer (buf, 2, byte_order, struct_addr);
|
|
|
|
|
sp -= 2;
|
|
|
|
|
write_memory (rl78_make_data_address (sp), buf, 2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Store return address. */
|
|
|
|
|
sp -= 4;
|
|
|
|
|
store_unsigned_integer (buf, 4, byte_order, bp_addr);
|
|
|
|
|
write_memory (rl78_make_data_address (sp), buf, 4);
|
|
|
|
|
|
|
|
|
|
/* Finally, update the stack pointer... */
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, RL78_SP_REGNUM, sp);
|
|
|
|
|
|
|
|
|
|
/* DWARF2/GCC uses the stack address *before* the function call as a
|
|
|
|
|
frame's CFA. */
|
|
|
|
|
return rl78_make_data_address (sp + 4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate and initialize a gdbarch object. */
|
|
|
|
|
|
|
|
|
|
static struct gdbarch *
|
|
|
|
|
rl78_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch *gdbarch;
|
|
|
|
|
struct gdbarch_tdep *tdep;
|
|
|
|
|
int elf_flags;
|
|
|
|
|
|
|
|
|
|
/* Extract the elf_flags if available. */
|
|
|
|
|
if (info.abfd != NULL
|
|
|
|
|
&& bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
|
|
|
|
|
elf_flags = elf_elfheader (info.abfd)->e_flags;
|
|
|
|
|
else
|
|
|
|
|
elf_flags = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Try to find the architecture in the list of already defined
|
|
|
|
|
architectures. */
|
|
|
|
|
for (arches = gdbarch_list_lookup_by_info (arches, &info);
|
|
|
|
|
arches != NULL;
|
|
|
|
|
arches = gdbarch_list_lookup_by_info (arches->next, &info))
|
|
|
|
|
{
|
|
|
|
|
if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
return arches->gdbarch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* None found, create a new architecture from the information
|
|
|
|
|
provided. */
|
2017-04-13 15:29:43 +08:00
|
|
|
tdep = XCNEW (struct gdbarch_tdep);
|
2012-02-04 14:05:50 +08:00
|
|
|
gdbarch = gdbarch_alloc (&info, tdep);
|
|
|
|
|
tdep->elf_flags = elf_flags;
|
|
|
|
|
|
|
|
|
|
/* Initialize types. */
|
|
|
|
|
tdep->rl78_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
|
|
|
|
|
tdep->rl78_uint8 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
|
|
|
|
|
tdep->rl78_int8 = arch_integer_type (gdbarch, 8, 0, "int8_t");
|
|
|
|
|
tdep->rl78_uint16 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
|
|
|
|
|
tdep->rl78_int16 = arch_integer_type (gdbarch, 16, 0, "int16_t");
|
|
|
|
|
tdep->rl78_uint32 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
|
|
|
|
|
tdep->rl78_int32 = arch_integer_type (gdbarch, 32, 0, "int32_t");
|
|
|
|
|
|
|
|
|
|
tdep->rl78_data_pointer
|
2016-09-06 23:26:32 +08:00
|
|
|
= arch_pointer_type (gdbarch, 16, "rl78_data_addr_t", tdep->rl78_void);
|
2012-02-04 14:05:50 +08:00
|
|
|
tdep->rl78_code_pointer
|
2016-09-06 23:26:32 +08:00
|
|
|
= arch_pointer_type (gdbarch, 32, "rl78_code_addr_t", tdep->rl78_void);
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
/* Registers. */
|
|
|
|
|
set_gdbarch_num_regs (gdbarch, RL78_NUM_REGS);
|
|
|
|
|
set_gdbarch_num_pseudo_regs (gdbarch, RL78_NUM_PSEUDO_REGS);
|
2014-02-18 03:03:23 +08:00
|
|
|
if (tdep->elf_flags & E_FLAG_RL78_G10)
|
|
|
|
|
set_gdbarch_register_name (gdbarch, rl78_g10_register_name);
|
|
|
|
|
else
|
|
|
|
|
set_gdbarch_register_name (gdbarch, rl78_register_name);
|
2012-02-04 14:05:50 +08:00
|
|
|
set_gdbarch_register_type (gdbarch, rl78_register_type);
|
|
|
|
|
set_gdbarch_pc_regnum (gdbarch, RL78_PC_REGNUM);
|
|
|
|
|
set_gdbarch_sp_regnum (gdbarch, RL78_SP_REGNUM);
|
|
|
|
|
set_gdbarch_pseudo_register_read (gdbarch, rl78_pseudo_register_read);
|
|
|
|
|
set_gdbarch_pseudo_register_write (gdbarch, rl78_pseudo_register_write);
|
|
|
|
|
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rl78_dwarf_reg_to_regnum);
|
2012-02-15 04:15:44 +08:00
|
|
|
set_gdbarch_register_reggroup_p (gdbarch, rl78_register_reggroup_p);
|
|
|
|
|
set_gdbarch_register_sim_regno (gdbarch, rl78_register_sim_regno);
|
2012-02-04 14:05:50 +08:00
|
|
|
|
|
|
|
|
/* Data types. */
|
|
|
|
|
set_gdbarch_char_signed (gdbarch, 0);
|
|
|
|
|
set_gdbarch_short_bit (gdbarch, 16);
|
|
|
|
|
set_gdbarch_int_bit (gdbarch, 16);
|
|
|
|
|
set_gdbarch_long_bit (gdbarch, 32);
|
|
|
|
|
set_gdbarch_long_long_bit (gdbarch, 64);
|
|
|
|
|
set_gdbarch_ptr_bit (gdbarch, 16);
|
|
|
|
|
set_gdbarch_addr_bit (gdbarch, 32);
|
2013-05-04 14:14:53 +08:00
|
|
|
set_gdbarch_dwarf2_addr_size (gdbarch, 4);
|
2012-02-04 14:05:50 +08:00
|
|
|
set_gdbarch_float_bit (gdbarch, 32);
|
|
|
|
|
set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
|
|
|
|
|
set_gdbarch_double_bit (gdbarch, 32);
|
|
|
|
|
set_gdbarch_long_double_bit (gdbarch, 64);
|
|
|
|
|
set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
|
|
|
|
|
set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
|
|
|
|
|
set_gdbarch_pointer_to_address (gdbarch, rl78_pointer_to_address);
|
|
|
|
|
set_gdbarch_address_to_pointer (gdbarch, rl78_address_to_pointer);
|
|
|
|
|
set_gdbarch_addr_bits_remove (gdbarch, rl78_addr_bits_remove);
|
|
|
|
|
|
|
|
|
|
/* Breakpoints. */
|
2016-11-03 22:35:14 +08:00
|
|
|
set_gdbarch_breakpoint_kind_from_pc (gdbarch, rl78_breakpoint::kind_from_pc);
|
|
|
|
|
set_gdbarch_sw_breakpoint_from_kind (gdbarch, rl78_breakpoint::bp_from_kind);
|
2012-02-04 14:05:50 +08:00
|
|
|
set_gdbarch_decr_pc_after_break (gdbarch, 1);
|
|
|
|
|
|
|
|
|
|
/* Frames, prologues, etc. */
|
|
|
|
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
|
|
|
|
set_gdbarch_skip_prologue (gdbarch, rl78_skip_prologue);
|
|
|
|
|
set_gdbarch_unwind_pc (gdbarch, rl78_unwind_pc);
|
|
|
|
|
set_gdbarch_unwind_sp (gdbarch, rl78_unwind_sp);
|
|
|
|
|
set_gdbarch_frame_align (gdbarch, rl78_frame_align);
|
2013-05-04 14:14:53 +08:00
|
|
|
|
|
|
|
|
dwarf2_append_unwinders (gdbarch);
|
2012-02-04 14:05:50 +08:00
|
|
|
frame_unwind_append_unwinder (gdbarch, &rl78_unwind);
|
|
|
|
|
|
|
|
|
|
/* Dummy frames, return values. */
|
|
|
|
|
set_gdbarch_dummy_id (gdbarch, rl78_dummy_id);
|
|
|
|
|
set_gdbarch_push_dummy_call (gdbarch, rl78_push_dummy_call);
|
|
|
|
|
set_gdbarch_return_value (gdbarch, rl78_return_value);
|
|
|
|
|
|
|
|
|
|
/* Virtual tables. */
|
|
|
|
|
set_gdbarch_vbit_in_delta (gdbarch, 1);
|
|
|
|
|
|
|
|
|
|
return gdbarch;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-02 08:06:13 +08:00
|
|
|
/* -Wmissing-prototypes */
|
|
|
|
|
extern initialize_file_ftype _initialize_rl78_tdep;
|
|
|
|
|
|
2012-02-04 14:05:50 +08:00
|
|
|
/* Register the above initialization routine. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_initialize_rl78_tdep (void)
|
|
|
|
|
{
|
|
|
|
|
register_gdbarch_init (bfd_arch_rl78, rl78_gdbarch_init);
|
|
|
|
|
}
|
