[deliverable/binutils-gdb.git] / include / opcode / rx.h

/* Opcode decoder for the Renesas RX
   Copyright 2008, 2009, 2010
   Free Software Foundation, Inc.
   Written by DJ Delorie <dj@redhat.com>

   This file is part of GDB, the GNU Debugger and GAS, the GNU Assembler.

   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, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */

/* The RX decoder in libopcodes is used by the simulator, gdb's
   analyzer, and the disassembler.  Given an opcode data source,
   it decodes the next opcode into the following structures.  */

typedef enum
{
  RX_AnySize = 0,
  RX_Byte, /* undefined extension */
  RX_UByte,
  RX_SByte,
  RX_Word, /* undefined extension */
  RX_UWord,
  RX_SWord,
  RX_3Byte,
  RX_Long,
} RX_Size;

typedef enum
{
  RX_Operand_None,
  RX_Operand_Immediate,	/* #addend */
  RX_Operand_Register,	/* Rn */
  RX_Operand_Indirect,	/* [Rn + addend] */
  RX_Operand_Postinc,	/* [Rn+] */
  RX_Operand_Predec,	/* [-Rn] */
  RX_Operand_Condition,	/* eq, gtu, etc */
  RX_Operand_Flag,	/* [UIOSZC] */
} RX_Operand_Type;

typedef enum
{
  RXO_unknown,
  RXO_mov,	/* d = s (signed) */
  RXO_movbi,	/* d = [s,s2] (signed) */
  RXO_movbir,	/* [s,s2] = d (signed) */
  RXO_pushm,	/* s..s2 */
  RXO_popm,	/* s..s2 */
  RXO_xchg,	/* s <-> d */
  RXO_stcc,	/* d = s if cond(s2) */
  RXO_rtsd,	/* rtsd, 1=imm, 2-0 = reg if reg type */

  /* These are all either d OP= s or, if s2 is set, d = s OP s2.  Note
     that d may be "None".  */
  RXO_and,
  RXO_or,
  RXO_xor,
  RXO_add,
  RXO_sub,
  RXO_mul,
  RXO_div,
  RXO_divu,
  RXO_shll,
  RXO_shar,
  RXO_shlr,

  RXO_adc,	/* d = d + s + carry */
  RXO_sbb,	/* d = d - s - ~carry */
  RXO_abs,	/* d = |s| */
  RXO_max,	/* d = max(d,s) */
  RXO_min,	/* d = min(d,s) */
  RXO_emul,	/* d:64 = d:32 * s */
  RXO_emulu,	/* d:64 = d:32 * s (unsigned) */
  RXO_ediv,	/* d:64 / s; d = quot, d+1 = rem */
  RXO_edivu,	/* d:64 / s; d = quot, d+1 = rem */

  RXO_rolc,	/* d <<= 1 through carry */
  RXO_rorc,	/* d >>= 1 through carry*/
  RXO_rotl,	/* d <<= #s without carry */
  RXO_rotr,	/* d >>= #s without carry*/
  RXO_revw,	/* d = revw(s) */
  RXO_revl,	/* d = revl(s) */
  RXO_branch,	/* pc = d if cond(s) */
  RXO_branchrel,/* pc += d if cond(s) */
  RXO_jsr,	/* pc = d */
  RXO_jsrrel,	/* pc += d */
  RXO_rts,
  RXO_nop,
  RXO_nop2,
  RXO_nop3,

  RXO_scmpu,
  RXO_smovu,
  RXO_smovb,
  RXO_suntil,
  RXO_swhile,
  RXO_smovf,
  RXO_sstr,

  RXO_rmpa,
  RXO_mulhi,
  RXO_mullo,
  RXO_machi,
  RXO_maclo,
  RXO_mvtachi,
  RXO_mvtaclo,
  RXO_mvfachi,
  RXO_mvfacmi,
  RXO_mvfaclo,
  RXO_racw,

  RXO_sat,	/* sat(d) */
  RXO_satr,

  RXO_fadd,	/* d op= s */
  RXO_fcmp,
  RXO_fsub,
  RXO_ftoi,
  RXO_fmul,
  RXO_fdiv,
  RXO_round,
  RXO_itof,

  RXO_bset,	/* d |= (1<<s) */
  RXO_bclr,	/* d &= ~(1<<s) */
  RXO_btst,	/* s & (1<<s2) */
  RXO_bnot,	/* d ^= (1<<s) */
  RXO_bmcc,	/* d<s> = cond(s2) */

  RXO_clrpsw,	/* flag index in d */
  RXO_setpsw,	/* flag index in d */
  RXO_mvtipl,	/* new IPL in s */

  RXO_rtfi,
  RXO_rte,
  RXO_rtd,	/* undocumented */
  RXO_brk,
  RXO_dbt,	/* undocumented */
  RXO_int,	/* vector id in s */
  RXO_stop,
  RXO_wait,

  RXO_sccnd,	/* d = cond(s) ? 1 : 0 */
} RX_Opcode_ID;

/* Condition bitpatterns, as registers.  */
#define RXC_eq		0
#define RXC_z		0
#define RXC_ne		1
#define RXC_nz		1
#define RXC_c		2
#define RXC_nc		3
#define RXC_gtu		4
#define RXC_leu		5
#define RXC_pz		6
#define RXC_n		7
#define RXC_ge		8
#define RXC_lt		9
#define RXC_gt		10
#define RXC_le		11
#define RXC_o		12
#define RXC_no		13
#define RXC_always	14
#define RXC_never	15

typedef struct
{
  RX_Operand_Type  type;
  int              reg;
  int              addend;
  RX_Size          size;
} RX_Opcode_Operand;

typedef struct
{
  RX_Opcode_ID      id;
  int               n_bytes;
  int               prefix;
  char *            syntax;
  RX_Size           size;
  /* By convention, these are destination, source1, source2.  */
  RX_Opcode_Operand op[3];

  /* The logic here is:
     newflags = (oldflags & ~(int)flags_0) | flags_1 | (op_flags & flags_s)
     Only the O, S, Z, and C flags are affected.  */
  char flags_0; /* This also clears out flags-to-be-set.  */
  char flags_1;
  char flags_s;
} RX_Opcode_Decoded;

/* Within the syntax, %c-style format specifiers are as follows:

   %% = '%' character
   %0 = operand[0] (destination)
   %1 = operand[1] (source)
   %2 = operand[2] (2nd source)
   %s = operation size (b/w/l)
   %SN = operand size [N] (N=0,1,2)
   %aN = op[N] as an address (N=0,1,2)

   Register numbers 0..15 are general registers.  16..31 are control
   registers.  32..47 are condition codes.  */

int rx_decode_opcode (unsigned long, RX_Opcode_Decoded *, int (*)(void *), void *);
Commit	Line	Data
c7927a3c	1	/* Opcode decoder for the Renesas RX
e4e42b45	2	Copyright 2008, 2009, 2010
c7927a3c NC	3	Free Software Foundation, Inc.
	4	Written by DJ Delorie <dj@redhat.com>
	5
	6	This file is part of GDB, the GNU Debugger and GAS, the GNU Assembler.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
e4e42b45	10	the Free Software Foundation; either version 3 of the License, or
c7927a3c NC	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
	21	02110-1301, USA. */
	22
	23	/* The RX decoder in libopcodes is used by the simulator, gdb's
	24	analyzer, and the disassembler. Given an opcode data source,
	25	it decodes the next opcode into the following structures. */
	26
	27	typedef enum
	28	{
	29	RX_AnySize = 0,
	30	RX_Byte, /* undefined extension */
	31	RX_UByte,
	32	RX_SByte,
	33	RX_Word, /* undefined extension */
	34	RX_UWord,
	35	RX_SWord,
	36	RX_3Byte,
	37	RX_Long,
	38	} RX_Size;
	39
	40	typedef enum
	41	{
	42	RX_Operand_None,
	43	RX_Operand_Immediate, /* #addend */
	44	RX_Operand_Register, /* Rn */
	45	RX_Operand_Indirect, /* [Rn + addend] */
	46	RX_Operand_Postinc, /* [Rn+] */
	47	RX_Operand_Predec, /* [-Rn] */
	48	RX_Operand_Condition, /* eq, gtu, etc */
	49	RX_Operand_Flag, /* [UIOSZC] */
	50	} RX_Operand_Type;
	51
	52	typedef enum
	53	{
	54	RXO_unknown,
	55	RXO_mov, /* d = s (signed) */
	56	RXO_movbi, /* d = [s,s2] (signed) */
	57	RXO_movbir, /* [s,s2] = d (signed) */
	58	RXO_pushm, /* s..s2 */
	59	RXO_popm, /* s..s2 */
c7927a3c NC	60	RXO_xchg, /* s <-> d */
	61	RXO_stcc, /* d = s if cond(s2) */
	62	RXO_rtsd, /* rtsd, 1=imm, 2-0 = reg if reg type */
	63
	64	/* These are all either d OP= s or, if s2 is set, d = s OP s2. Note
	65	that d may be "None". */
	66	RXO_and,
	67	RXO_or,
	68	RXO_xor,
	69	RXO_add,
	70	RXO_sub,
	71	RXO_mul,
	72	RXO_div,
	73	RXO_divu,
	74	RXO_shll,
	75	RXO_shar,
	76	RXO_shlr,
	77
	78	RXO_adc, /* d = d + s + carry */
	79	RXO_sbb, /* d = d - s - ~carry */
	80	RXO_abs, /* d = \|s\| */
	81	RXO_max, /* d = max(d,s) */
	82	RXO_min, /* d = min(d,s) */
	83	RXO_emul, /* d:64 = d:32 * s */
	84	RXO_emulu, /* d:64 = d:32 * s (unsigned) */
	85	RXO_ediv, /* d:64 / s; d = quot, d+1 = rem */
	86	RXO_edivu, /* d:64 / s; d = quot, d+1 = rem */
	87
	88	RXO_rolc, /* d <<= 1 through carry */
	89	RXO_rorc, /* d >>= 1 through carry*/
	90	RXO_rotl, /* d <<= #s without carry */
	91	RXO_rotr, /* d >>= #s without carry*/
	92	RXO_revw, /* d = revw(s) */
	93	RXO_revl, /* d = revl(s) */
	94	RXO_branch, /* pc = d if cond(s) */
	95	RXO_branchrel,/* pc += d if cond(s) */
	96	RXO_jsr, /* pc = d */
	97	RXO_jsrrel, /* pc += d */
	98	RXO_rts,
	99	RXO_nop,
93378652 DD	100	RXO_nop2,
93378652 DD	101	RXO_nop3,
c7927a3c NC	102
	103	RXO_scmpu,
	104	RXO_smovu,
	105	RXO_smovb,
	106	RXO_suntil,
	107	RXO_swhile,
	108	RXO_smovf,
	109	RXO_sstr,
	110
	111	RXO_rmpa,
	112	RXO_mulhi,
	113	RXO_mullo,
	114	RXO_machi,
	115	RXO_maclo,
	116	RXO_mvtachi,
	117	RXO_mvtaclo,
	118	RXO_mvfachi,
	119	RXO_mvfacmi,
	120	RXO_mvfaclo,
	121	RXO_racw,
	122
	123	RXO_sat, /* sat(d) */
	124	RXO_satr,
	125
	126	RXO_fadd, /* d op= s */
	127	RXO_fcmp,
	128	RXO_fsub,
	129	RXO_ftoi,
	130	RXO_fmul,
	131	RXO_fdiv,
	132	RXO_round,
	133	RXO_itof,
	134
	135	RXO_bset, /* d \|= (1<<s) */
	136	RXO_bclr, /* d &= ~(1<<s) */
	137	RXO_btst, /* s & (1<<s2) */
	138	RXO_bnot, /* d ^= (1<<s) */
	139	RXO_bmcc, /* d<s> = cond(s2) */
	140
	141	RXO_clrpsw, /* flag index in d */
	142	RXO_setpsw, /* flag index in d */
0d734b5d	143	RXO_mvtipl, /* new IPL in s */
c7927a3c NC	144
	145	RXO_rtfi,
	146	RXO_rte,
	147	RXO_rtd, /* undocumented */
	148	RXO_brk,
	149	RXO_dbt, /* undocumented */
	150	RXO_int, /* vector id in s */
	151	RXO_stop,
	152	RXO_wait,
	153
	154	RXO_sccnd, /* d = cond(s) ? 1 : 0 */
	155	} RX_Opcode_ID;
	156
	157	/* Condition bitpatterns, as registers. */
	158	#define RXC_eq 0
	159	#define RXC_z 0
	160	#define RXC_ne 1
	161	#define RXC_nz 1
	162	#define RXC_c 2
	163	#define RXC_nc 3
	164	#define RXC_gtu 4
	165	#define RXC_leu 5
	166	#define RXC_pz 6
	167	#define RXC_n 7
	168	#define RXC_ge 8
	169	#define RXC_lt 9
	170	#define RXC_gt 10
	171	#define RXC_le 11
	172	#define RXC_o 12
	173	#define RXC_no 13
	174	#define RXC_always 14
	175	#define RXC_never 15
	176
	177	typedef struct
	178	{
	179	RX_Operand_Type type;
	180	int reg;
	181	int addend;
	182	RX_Size size;
	183	} RX_Opcode_Operand;
	184
	185	typedef struct
	186	{
	187	RX_Opcode_ID id;
	188	int n_bytes;
	189	int prefix;
	190	char * syntax;
	191	RX_Size size;
	192	/* By convention, these are destination, source1, source2. */
	193	RX_Opcode_Operand op[3];
	194
	195	/* The logic here is:
	196	newflags = (oldflags & ~(int)flags_0) \| flags_1 \| (op_flags & flags_s)
	197	Only the O, S, Z, and C flags are affected. */
	198	char flags_0; /* This also clears out flags-to-be-set. */
	199	char flags_1;
	200	char flags_s;
	201	} RX_Opcode_Decoded;
	202
	203	/* Within the syntax, %c-style format specifiers are as follows:
	204
	205	%% = '%' character
	206	%0 = operand[0] (destination)
	207	%1 = operand[1] (source)
208	%2 = operand[2] (2nd source)
209	%s = operation size (b/w/l)
210	%SN = operand size [N] (N=0,1,2)
211	%aN = op[N] as an address (N=0,1,2)
212
213	Register numbers 0..15 are general registers. 16..31 are control
214	registers. 32..47 are condition codes. */
215
216	int rx_decode_opcode (unsigned long, RX_Opcode_Decoded , int ()(void ), void );