include/opcode/rx.h

   1 /* Opcode decoder for the Renesas RX
   2    Copyright 2008, 2009, 2010
   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
  10    the Free Software Foundation; either version 3 of the License, or
  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_TwoReg,    /* [Rn + scale*R2] */
  51 } RX_Operand_Type;
  52
  53 typedef enum
  54 {
  55   RXO_unknown,
  56   RXO_mov,      /* d = s (signed) */
  57   RXO_movbi,    /* d = [s,s2] (signed) */
  58   RXO_movbir,   /* [s,s2] = d (signed) */
  59   RXO_pushm,    /* s..s2 */
  60   RXO_popm,     /* s..s2 */
  61   RXO_xchg,     /* s <-> d */
  62   RXO_stcc,     /* d = s if cond(s2) */
  63   RXO_rtsd,     /* rtsd, 1=imm, 2-0 = reg if reg type */
  64
  65   /* These are all either d OP= s or, if s2 is set, d = s OP s2.  Note
  66      that d may be "None".  */
  67   RXO_and,
  68   RXO_or,
  69   RXO_xor,
  70   RXO_add,
  71   RXO_sub,
  72   RXO_mul,
  73   RXO_div,
  74   RXO_divu,
  75   RXO_shll,
  76   RXO_shar,
  77   RXO_shlr,
  78
  79   RXO_adc,      /* d = d + s + carry */
  80   RXO_sbb,      /* d = d - s - ~carry */
  81   RXO_abs,      /* d = |s| */
  82   RXO_max,      /* d = max(d,s) */
  83   RXO_min,      /* d = min(d,s) */
  84   RXO_emul,     /* d:64 = d:32 * s */
  85   RXO_emulu,    /* d:64 = d:32 * s (unsigned) */
  86
  87   RXO_rolc,     /* d <<= 1 through carry */
  88   RXO_rorc,     /* d >>= 1 through carry*/
  89   RXO_rotl,     /* d <<= #s without carry */
  90   RXO_rotr,     /* d >>= #s without carry*/
  91   RXO_revw,     /* d = revw(s) */
  92   RXO_revl,     /* d = revl(s) */
  93   RXO_branch,   /* pc = d if cond(s) */
  94   RXO_branchrel,/* pc += d if cond(s) */
  95   RXO_jsr,      /* pc = d */
  96   RXO_jsrrel,   /* pc += d */
  97   RXO_rts,
  98   RXO_nop,
  99   RXO_nop2,
 100   RXO_nop3,
 101
 102   RXO_scmpu,
 103   RXO_smovu,
 104   RXO_smovb,
 105   RXO_suntil,
 106   RXO_swhile,
 107   RXO_smovf,
 108   RXO_sstr,
 109
 110   RXO_rmpa,
 111   RXO_mulhi,
 112   RXO_mullo,
 113   RXO_machi,
 114   RXO_maclo,
 115   RXO_mvtachi,
 116   RXO_mvtaclo,
 117   RXO_mvfachi,
 118   RXO_mvfacmi,
 119   RXO_mvfaclo,
 120   RXO_racw,
 121
 122   RXO_sat,      /* sat(d) */
 123   RXO_satr,
 124
 125   RXO_fadd,     /* d op= s */
 126   RXO_fcmp,
 127   RXO_fsub,
 128   RXO_ftoi,
 129   RXO_fmul,
 130   RXO_fdiv,
 131   RXO_round,
 132   RXO_itof,
 133
 134   RXO_bset,     /* d |= (1<<s) */
 135   RXO_bclr,     /* d &= ~(1<<s) */
 136   RXO_btst,     /* s & (1<<s2) */
 137   RXO_bnot,     /* d ^= (1<<s) */
 138   RXO_bmcc,     /* d<s> = cond(s2) */
 139
 140   RXO_clrpsw,   /* flag index in d */
 141   RXO_setpsw,   /* flag index in d */
 142   RXO_mvtipl,   /* new IPL in s */
 143
 144   RXO_rtfi,
 145   RXO_rte,
 146   RXO_rtd,      /* undocumented */
 147   RXO_brk,
 148   RXO_dbt,      /* undocumented */
 149   RXO_int,      /* vector id in s */
 150   RXO_stop,
 151   RXO_wait,
 152
 153   RXO_sccnd,    /* d = cond(s) ? 1 : 0 */
 154 } RX_Opcode_ID;
 155
 156 /* Condition bitpatterns, as registers.  */
 157 #define RXC_eq          0
 158 #define RXC_z           0
 159 #define RXC_ne          1
 160 #define RXC_nz          1
 161 #define RXC_c           2
 162 #define RXC_nc          3
 163 #define RXC_gtu         4
 164 #define RXC_leu         5
 165 #define RXC_pz          6
 166 #define RXC_n           7
 167 #define RXC_ge          8
 168 #define RXC_lt          9
 169 #define RXC_gt          10
 170 #define RXC_le          11
 171 #define RXC_o           12
 172 #define RXC_no          13
 173 #define RXC_always      14
 174 #define RXC_never       15
 175
 176 typedef struct
 177 {
 178   RX_Operand_Type  type;
 179   int              reg;
 180   int              addend;
 181   RX_Size          size;
 182 } RX_Opcode_Operand;
 183
 184 typedef struct
 185 {
 186   RX_Opcode_ID      id;
 187   int               n_bytes;
 188   int               prefix;
 189   char *            syntax;
 190   RX_Size           size;
 191   /* By convention, these are destination, source1, source2.  */
 192   RX_Opcode_Operand op[3];
 193
 194   /* The logic here is:
 195      newflags = (oldflags & ~(int)flags_0) | flags_1 | (op_flags & flags_s)
 196      Only the O, S, Z, and C flags are affected.  */
 197   char flags_0; /* This also clears out flags-to-be-set.  */
 198   char flags_1;
 199   char flags_s;
 200 } RX_Opcode_Decoded;
 201
 202 /* Within the syntax, %c-style format specifiers are as follows:
 203
 204    %% = '%' character
 205    %0 = operand[0] (destination)
 206    %1 = operand[1] (source)
 207    %2 = operand[2] (2nd source)
 208    %s = operation size (b/w/l)
 209    %SN = operand size [N] (N=0,1,2)
 210    %aN = op[N] as an address (N=0,1,2)
 211
 212    Register numbers 0..15 are general registers.  16..31 are control
 213    registers.  32..47 are condition codes.  */
 214
 215 int rx_decode_opcode (unsigned long, RX_Opcode_Decoded *, int (*)(void *), void *);