include/opcode/arm.h

   1 /* ARM opcode list.
   2    Copyright 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB and GAS.
   5
   6 GDB and GAS are free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GDB and GAS are distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GDB or GAS; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 /* types of instruction (encoded in bits 26 and 27 of the instruction) */
  21
  22 #define TYPE_ARITHMETIC         0
  23 #define TYPE_LDR_STR            1
  24 #define TYPE_BLOCK_BRANCH       2
  25 #define TYPE_SWI                3
  26
  27 /* bit 25 decides whether an instruction is a block move or a branch */
  28 #define SUBTYPE_BLOCK           0
  29 #define SUBTYPE_BRANCH          1
  30
  31 /* codes to distinguish the arithmetic instructions */
  32
  33 #define OPCODE_AND      0
  34 #define OPCODE_EOR      1
  35 #define OPCODE_SUB      2
  36 #define OPCODE_RSB      3
  37 #define OPCODE_ADD      4
  38 #define OPCODE_ADC      5
  39 #define OPCODE_SBC      6
  40 #define OPCODE_RSC      7
  41 #define OPCODE_TST      8
  42 #define OPCODE_TEQ      9
  43 #define OPCODE_CMP      10
  44 #define OPCODE_CMN      11
  45 #define OPCODE_ORR      12
  46 #define OPCODE_MOV      13
  47 #define OPCODE_BIC      14
  48 #define OPCODE_MVN      15
  49
  50 /* condition codes */
  51
  52 #define COND_EQ         0
  53 #define COND_NE         1
  54 #define COND_CS         2
  55 #define COND_CC         3
  56 #define COND_MI         4
  57 #define COND_PL         5
  58 #define COND_VS         6
  59 #define COND_VC         7
  60 #define COND_HI         8
  61 #define COND_LS         9
  62 #define COND_GE         10
  63 #define COND_LT         11
  64 #define COND_GT         12
  65 #define COND_LE         13
  66 #define COND_AL         14
  67 #define COND_NV         15
  68
  69 /* Describes the format of an ARM machine instruction */
  70
  71 struct generic_fmt {
  72     unsigned rest       :25;    /* the rest of the instruction */
  73     unsigned subtype    :1;     /* used to decide between block and branch */
  74     unsigned type       :2;     /* one of TYPE_* */
  75     unsigned cond       :4;     /* one of COND_* defined above */
  76 };
  77
  78 struct arith_fmt {
  79     unsigned operand2   :12;    /* #nn or rn or rn shift #m or rn shift rm */
  80     unsigned dest       :4;     /* place where the answer goes */
  81     unsigned operand1   :4;     /* first operand to instruction */
  82     unsigned set        :1;     /* == 1 means set processor flags */
  83     unsigned opcode     :4;     /* one of OPCODE_* defined above */
  84     unsigned immed      :1;     /* operand2 is an immediate value */
  85     unsigned type       :2;     /* == TYPE_ARITHMETIC */
  86     unsigned cond       :4;     /* one of COND_* defined above */
  87 };
  88
  89 struct ldr_str_fmt {
  90     unsigned offset     :12;    /* #nn or rn or rn shift #m */
  91     unsigned reg        :4;     /* destination for LDR, source for STR */
  92     unsigned base       :4;     /* base register */
  93     unsigned is_load    :1;     /* == 1 for LDR */
  94     unsigned writeback  :1;     /* == 1 means write back (base+offset) into base */
  95     unsigned byte       :1;     /* == 1 means byte access else word */
  96     unsigned up         :1;     /* == 1 means add offset else subtract it */
  97     unsigned pre_index  :1;     /* == 1 means [a,b] form else [a],b form */
  98     unsigned immed      :1;     /* == 0 means immediate offset */
  99     unsigned type       :2;     /* == TYPE_LDR_STR */
 100     unsigned cond       :4;     /* one of COND_* defined above */
 101 };
 102
 103 struct block_fmt {
 104     unsigned mask       :16;    /* register mask */
 105     unsigned base       :4;     /* register used as base of move */
 106     unsigned is_load    :1;     /* == 1 for LDM */
 107     unsigned writeback  :1;     /* == 1 means update base after move */
 108     unsigned set        :1;     /* == 1 means set flags in pc if included in mask */
 109     unsigned increment  :1;     /* == 1 means increment base register */
 110     unsigned before     :1;     /* == 1 means inc/dec before each move */
 111     unsigned is_block   :1;     /* == SUBTYPE_BLOCK */
 112     unsigned type       :2;     /* == TYPE_BLOCK_BRANCH */
 113     unsigned cond       :4;     /* one of COND_* defined above */
 114 };
 115
 116 struct branch_fmt {
 117     unsigned dest       :24;    /* destination of the branch */
 118     unsigned link       :1;     /* branch with link (function call) */
 119     unsigned is_branch  :1;     /* == SUBTYPE_BRANCH */
 120     unsigned type       :2;     /* == TYPE_BLOCK_BRANCH */
 121     unsigned cond       :4;     /* one of COND_* defined above */
 122 };
 123
 124 #define ROUND_N         0
 125 #define ROUND_P         1
 126 #define ROUND_M         2
 127 #define ROUND_Z         3
 128
 129 #define FLOAT2_MVF      0
 130 #define FLOAT2_MNF      1
 131 #define FLOAT2_ABS      2
 132 #define FLOAT2_RND      3
 133 #define FLOAT2_SQT      4
 134 #define FLOAT2_LOG      5
 135 #define FLOAT2_LGN      6
 136 #define FLOAT2_EXP      7
 137 #define FLOAT2_SIN      8
 138 #define FLOAT2_COS      9
 139 #define FLOAT2_TAN      10
 140 #define FLOAT2_ASN      11
 141 #define FLOAT2_ACS      12
 142 #define FLOAT2_ATN      13
 143
 144 #define FLOAT3_ADF      0
 145 #define FLOAT3_MUF      1
 146 #define FLOAT3_SUF      2
 147 #define FLOAT3_RSF      3
 148 #define FLOAT3_DVF      4
 149 #define FLOAT3_RDF      5
 150 #define FLOAT3_POW      6
 151 #define FLOAT3_RPW      7
 152 #define FLOAT3_RMF      8
 153 #define FLOAT3_FML      9
 154 #define FLOAT3_FDV      10
 155 #define FLOAT3_FRD      11
 156 #define FLOAT3_POL      12
 157
 158 struct float2_fmt {
 159     unsigned operand2   :3;     /* second operand */
 160     unsigned immed      :1;     /* == 1 if second operand is a constant */
 161     unsigned pad1       :1;     /* == 0 */
 162     unsigned rounding   :2;     /* ROUND_* */
 163     unsigned is_double  :1;     /* == 1 if precision is double (only if not extended) */
 164     unsigned pad2       :4;     /* == 1 */
 165     unsigned dest       :3;     /* destination */
 166     unsigned is_2_op    :1;     /* == 1 if 2 operand ins */
 167     unsigned operand1   :3;     /* first operand (only of is_2_op == 0) */
 168     unsigned is_extended :1;    /* == 1 if precision is extended */
 169     unsigned opcode     :4;     /* FLOAT2_* or FLOAT3_* depending on is_2_op */
 170     unsigned must_be_2  :2;     /* == 2 */
 171     unsigned type       :2;     /* == TYPE_SWI */
 172     unsigned cond       :4;     /* COND_* */
 173 };
 174
 175 struct swi_fmt {
 176     unsigned argument   :24;    /* argument to SWI (syscall number) */
 177     unsigned must_be_3  :2;     /* == 3 */
 178     unsigned type       :2;     /* == TYPE_SWI */
 179     unsigned cond       :4;     /* one of COND_* defined above */
 180 };
 181
 182 union insn_fmt {
 183     struct generic_fmt  generic;
 184     struct arith_fmt    arith;
 185     struct ldr_str_fmt  ldr_str;
 186     struct block_fmt    block;
 187     struct branch_fmt   branch;
 188     struct swi_fmt      swi;
 189     unsigned long       ins;
 190 };
 191
 192 struct opcode {
 193     unsigned long value, mask;  /* recognise instruction if (op&mask)==value */
 194     char *assembler;            /* how to disassemble this instruction */
 195 };
 196
 197 /* format of the assembler string :
 198
 199    %%                   %
 200    %<bitfield>d         print the bitfield in decimal
 201    %<bitfield>x         print the bitfield in hex
 202    %<bitfield>r         print as an ARM register
 203    %<bitfield>f         print a floating point constant if >7 else an fp register
 204    %c                   print condition code (always bits 28-31)
 205    %P                   print floating point precision in arithmetic insn
 206    %Q                   print floating point precision in ldf/stf insn
 207    %R                   print floating point rounding mode
 208    %<bitnum>'c          print specified char iff bit is one
 209    %<bitnum>`c          print specified char iff bit is zero
 210    %<bitnum>?ab         print a if bit is one else print b
 211    %p                   print 'p' iff bits 12-15 are 15
 212    %o                   print operand2 (immediate or register + shift)
 213    %a                   print address for ldr/str instruction
 214    %b                   print branch destination
 215    %A                   print address for ldc/stc/ldf/stf instruction
 216    %m                   print register mask for ldm/stm instruction
 217 */
 218
 219 static struct opcode opcodes[] = {
 220     /* ARM instructions */
 221     0x00000090, 0x0fe000f0, "mul%20's %12-15r, %16-19r, %0-3r",
 222     0x00200090, 0x0fe000f0, "mla%20's %12-15r, %16-19r, %0-3r, %8-11r",
 223     0x00000000, 0x0de00000, "and%c%20's %12-15r, %16-19r, %o",
 224     0x00200000, 0x0de00000, "eor%c%20's %12-15r, %16-19r, %o",
 225     0x00400000, 0x0de00000, "sub%c%20's %12-15r, %16-19r, %o",
 226     0x00600000, 0x0de00000, "rsb%c%20's %12-15r, %16-19r, %o",
 227     0x00800000, 0x0de00000, "add%c%20's %12-15r, %16-19r, %o",
 228     0x00a00000, 0x0de00000, "adc%c%20's %12-15r, %16-19r, %o",
 229     0x00c00000, 0x0de00000, "sbc%c%20's %12-15r, %16-19r, %o",
 230     0x00e00000, 0x0de00000, "rsc%c%20's %12-15r, %16-19r, %o",
 231     0x01000000, 0x0de00000, "tst%c%p %16-19r, %o",
 232     0x01200000, 0x0de00000, "teq%c%p %16-19r, %o",
 233     0x01400000, 0x0de00000, "cmp%c%p %16-19r, %o",
 234     0x01600000, 0x0de00000, "cmn%c%p %16-19r, %o",
 235     0x01800000, 0x0de00000, "orr%c%20's %12-15r, %16-19r, %o",
 236     0x01a00000, 0x0de00000, "mov%c%20's %12-15r, %o",
 237     0x01c00000, 0x0de00000, "bic%c%20's %12-15r, %16-19r, %o",
 238     0x01e00000, 0x0de00000, "mvn%c%20's %12-15r, %o",
 239     0x04000000, 0x0c100000, "str%c%22'b %12-15r, %a",
 240     0x04100000, 0x0c100000, "ldr%c%22'b %12-15r, %a",
 241     0x08000000, 0x0e100000, "stm%c%23?id%24?ba %16-19r%22`!, %m",
 242     0x08100000, 0x0e100000, "ldm%c%23?id%24?ba %16-19r%22`!, %m%22'^",
 243     0x0a000000, 0x0e000000, "b%c%24'l %b",
 244     0x0f000000, 0x0f000000, "swi%c %0-23x",
 245     /* Floating point coprocessor instructions */
 246     0x0e000100, 0x0ff08f10, "adf%c%P%R %12-14f, %16-18f, %0-3f",
 247     0x0e100100, 0x0ff08f10, "muf%c%P%R %12-14f, %16-18f, %0-3f",
 248     0x0e200100, 0x0ff08f10, "suf%c%P%R %12-14f, %16-18f, %0-3f",
 249     0x0e300100, 0x0ff08f10, "rsf%c%P%R %12-14f, %16-18f, %0-3f",
 250     0x0e400100, 0x0ff08f10, "dvf%c%P%R %12-14f, %16-18f, %0-3f",
 251     0x0e500100, 0x0ff08f10, "rdf%c%P%R %12-14f, %16-18f, %0-3f",
 252     0x0e600100, 0x0ff08f10, "pow%c%P%R %12-14f, %16-18f, %0-3f",
 253     0x0e700100, 0x0ff08f10, "rpw%c%P%R %12-14f, %16-18f, %0-3f",
 254     0x0e800100, 0x0ff08f10, "rmf%c%P%R %12-14f, %16-18f, %0-3f",
 255     0x0e900100, 0x0ff08f10, "fml%c%P%R %12-14f, %16-18f, %0-3f",
 256     0x0ea00100, 0x0ff08f10, "fdv%c%P%R %12-14f, %16-18f, %0-3f",
 257     0x0eb00100, 0x0ff08f10, "frd%c%P%R %12-14f, %16-18f, %0-3f",
 258     0x0ec00100, 0x0ff08f10, "pol%c%P%R %12-14f, %16-18f, %0-3f",
 259     0x0e008100, 0x0ff08f10, "mvf%c%P%R %12-14f, %0-3f",
 260     0x0e108100, 0x0ff08f10, "mnf%c%P%R %12-14f, %0-3f",
 261     0x0e208100, 0x0ff08f10, "abs%c%P%R %12-14f, %0-3f",
 262     0x0e308100, 0x0ff08f10, "rnd%c%P%R %12-14f, %0-3f",
 263     0x0e408100, 0x0ff08f10, "sqt%c%P%R %12-14f, %0-3f",
 264     0x0e508100, 0x0ff08f10, "log%c%P%R %12-14f, %0-3f",
 265     0x0e608100, 0x0ff08f10, "lgn%c%P%R %12-14f, %0-3f",
 266     0x0e708100, 0x0ff08f10, "exp%c%P%R %12-14f, %0-3f",
 267     0x0e808100, 0x0ff08f10, "sin%c%P%R %12-14f, %0-3f",
 268     0x0e908100, 0x0ff08f10, "cos%c%P%R %12-14f, %0-3f",
 269     0x0ea08100, 0x0ff08f10, "tan%c%P%R %12-14f, %0-3f",
 270     0x0eb08100, 0x0ff08f10, "asn%c%P%R %12-14f, %0-3f",
 271     0x0ec08100, 0x0ff08f10, "acs%c%P%R %12-14f, %0-3f",
 272     0x0ed08100, 0x0ff08f10, "atn%c%P%R %12-14f, %0-3f",
 273     0x0e000110, 0x0ff00f1f, "flt%c%P%R %16-18f, %12-15r",
 274     0x0e100110, 0x0fff0f98, "fix%c%R %12-15r, %0-2f",
 275     0x0e200110, 0x0fff0fff, "wfs%c %12-15r",
 276     0x0e300110, 0x0fff0fff, "rfs%c %12-15r",
 277     0x0e400110, 0x0fff0fff, "wfc%c %12-15r",
 278     0x0e500110, 0x0fff0fff, "rfc%c %12-15r",
 279     0x0e90f110, 0x0ff8fff0, "cmf%c %16-18f, %0-3f",
 280     0x0eb0f110, 0x0ff8fff0, "cnf%c %16-18f, %0-3f",
 281     0x0ed0f110, 0x0ff8fff0, "cmfe%c %16-18f, %0-3f",
 282     0x0ef0f110, 0x0ff8fff0, "cnfe%c %16-18f, %0-3f",
 283     0x0c000100, 0x0e100f00, "stf%c%Q %12-14f, %A",
 284     0x0c100100, 0x0e100f00, "ldf%c%Q %12-14f, %A",
 285     /* Generic coprocessor instructions */
 286     0x0e000000, 0x0f000010, "cdp%c %8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}",
 287     0x0e000010, 0x0f100010, "mrc%c %8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}",
 288     0x0e100010, 0x0f100010, "mcr%c %8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}",
 289     0x0c000000, 0x0e100000, "stc%c%22`l %8-11d, cr%12-15d, %A",
 290     0x0c100000, 0x0e100000, "ldc%c%22`l %8-11d, cr%12-15d, %A",
 291     /* the rest */
 292     0x00000000, 0x00000000, "undefined instruction %0-31x",
 293 };
 294 #define N_OPCODES       (sizeof opcodes / sizeof opcodes[0])