Statistics
| Branch: | Revision:

root / arm-dis.c @ a74cdab4

History | View | Annotate | Download (157.1 kB)

1 aa0aa4fa bellard
/* Instruction printing code for the ARM
2 4b0f1a8b pbrook
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 4b0f1a8b pbrook
   2007, Free Software Foundation, Inc.
4 aa0aa4fa bellard
   Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
5 aa0aa4fa bellard
   Modification by James G. Smith (jsmith@cygnus.co.uk)
6 aa0aa4fa bellard

7 4b0f1a8b pbrook
   This file is part of libopcodes.
8 aa0aa4fa bellard

9 4b0f1a8b pbrook
   This program is free software; you can redistribute it and/or modify it under
10 4b0f1a8b pbrook
   the terms of the GNU General Public License as published by the Free
11 4b0f1a8b pbrook
   Software Foundation; either version 2 of the License, or (at your option)
12 4b0f1a8b pbrook
   any later version.
13 aa0aa4fa bellard

14 4b0f1a8b pbrook
   This program is distributed in the hope that it will be useful, but WITHOUT
15 4b0f1a8b pbrook
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 4b0f1a8b pbrook
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
17 4b0f1a8b pbrook
   more details.
18 aa0aa4fa bellard

19 4b0f1a8b pbrook
   You should have received a copy of the GNU General Public License
20 8167ee88 Blue Swirl
   along with this program; if not, see <http://www.gnu.org/licenses/>.  */
21 4b0f1a8b pbrook
22 4b0f1a8b pbrook
/* Start of qemu specific additions.  Mostly this is stub definitions
23 4b0f1a8b pbrook
   for things we don't care about.  */
24 aa0aa4fa bellard
25 aa0aa4fa bellard
#include "dis-asm.h"
26 4b0f1a8b pbrook
#define ATTRIBUTE_UNUSED __attribute__((unused))
27 4b0f1a8b pbrook
#define ISSPACE(x) ((x) == ' ' || (x) == '\t' || (x) == '\n')
28 4b0f1a8b pbrook
29 4b0f1a8b pbrook
#define ARM_EXT_V1         0
30 4b0f1a8b pbrook
#define ARM_EXT_V2         0
31 4b0f1a8b pbrook
#define ARM_EXT_V2S         0
32 4b0f1a8b pbrook
#define ARM_EXT_V3         0
33 4b0f1a8b pbrook
#define ARM_EXT_V3M         0
34 4b0f1a8b pbrook
#define ARM_EXT_V4         0
35 4b0f1a8b pbrook
#define ARM_EXT_V4T         0
36 4b0f1a8b pbrook
#define ARM_EXT_V5         0
37 4b0f1a8b pbrook
#define ARM_EXT_V5T         0
38 4b0f1a8b pbrook
#define ARM_EXT_V5ExP         0
39 4b0f1a8b pbrook
#define ARM_EXT_V5E         0
40 4b0f1a8b pbrook
#define ARM_EXT_V5J         0
41 4b0f1a8b pbrook
#define ARM_EXT_V6       0
42 4b0f1a8b pbrook
#define ARM_EXT_V6K      0
43 4b0f1a8b pbrook
#define ARM_EXT_V6Z      0
44 4b0f1a8b pbrook
#define ARM_EXT_V6T2         0
45 4b0f1a8b pbrook
#define ARM_EXT_V7         0
46 4b0f1a8b pbrook
#define ARM_EXT_DIV         0
47 4b0f1a8b pbrook
48 4b0f1a8b pbrook
/* Co-processor space extensions.  */
49 4b0f1a8b pbrook
#define ARM_CEXT_XSCALE   0
50 4b0f1a8b pbrook
#define ARM_CEXT_MAVERICK 0
51 4b0f1a8b pbrook
#define ARM_CEXT_IWMMXT   0
52 4b0f1a8b pbrook
53 4b0f1a8b pbrook
#define FPU_FPA_EXT_V1         0
54 4b0f1a8b pbrook
#define FPU_FPA_EXT_V2         0
55 4b0f1a8b pbrook
#define FPU_VFP_EXT_NONE 0
56 4b0f1a8b pbrook
#define FPU_VFP_EXT_V1xD 0
57 4b0f1a8b pbrook
#define FPU_VFP_EXT_V1         0
58 4b0f1a8b pbrook
#define FPU_VFP_EXT_V2         0
59 4b0f1a8b pbrook
#define FPU_MAVERICK         0
60 4b0f1a8b pbrook
#define FPU_VFP_EXT_V3         0
61 4b0f1a8b pbrook
#define FPU_NEON_EXT_V1         0
62 4b0f1a8b pbrook
63 4b0f1a8b pbrook
/* Assume host uses ieee float.  */
64 e3b283e9 Stefan Weil
static void floatformat_to_double (unsigned char *data, double *dest)
65 4b0f1a8b pbrook
{
66 4b0f1a8b pbrook
    union {
67 4b0f1a8b pbrook
        uint32_t i;
68 4b0f1a8b pbrook
        float f;
69 4b0f1a8b pbrook
    } u;
70 4b0f1a8b pbrook
    u.i = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
71 4b0f1a8b pbrook
    *dest = u.f;
72 4b0f1a8b pbrook
}
73 4b0f1a8b pbrook
74 4b0f1a8b pbrook
/* End of qemu specific additions.  */
75 4b0f1a8b pbrook
76 4b0f1a8b pbrook
/* FIXME: Belongs in global header.  */
77 4b0f1a8b pbrook
#ifndef strneq
78 4b0f1a8b pbrook
#define strneq(a,b,n)        (strncmp ((a), (b), (n)) == 0)
79 4b0f1a8b pbrook
#endif
80 aa0aa4fa bellard
81 4b0f1a8b pbrook
#ifndef NUM_ELEM
82 4b0f1a8b pbrook
#define NUM_ELEM(a)     (sizeof (a) / sizeof (a)[0])
83 4b0f1a8b pbrook
#endif
84 4b0f1a8b pbrook
85 4b0f1a8b pbrook
struct opcode32
86 4b0f1a8b pbrook
{
87 4b0f1a8b pbrook
  unsigned long arch;                /* Architecture defining this insn.  */
88 4b0f1a8b pbrook
  unsigned long value, mask;        /* Recognise insn if (op&mask)==value.  */
89 4b0f1a8b pbrook
  const char *assembler;        /* How to disassemble this insn.  */
90 aa0aa4fa bellard
};
91 aa0aa4fa bellard
92 4b0f1a8b pbrook
struct opcode16
93 aa0aa4fa bellard
{
94 4b0f1a8b pbrook
  unsigned long arch;                /* Architecture defining this insn.  */
95 4b0f1a8b pbrook
  unsigned short value, mask;        /* Recognise insn if (op&mask)==value.  */
96 4b0f1a8b pbrook
  const char *assembler;        /* How to disassemble this insn.  */
97 aa0aa4fa bellard
};
98 aa0aa4fa bellard
99 4b0f1a8b pbrook
/* print_insn_coprocessor recognizes the following format control codes:
100 3b46e624 ths

101 aa0aa4fa bellard
   %%                        %
102 4b0f1a8b pbrook

103 4b0f1a8b pbrook
   %c                        print condition code (always bits 28-31 in ARM mode)
104 4b0f1a8b pbrook
   %q                        print shifter argument
105 4b0f1a8b pbrook
   %u                        print condition code (unconditional in ARM mode)
106 4b0f1a8b pbrook
   %A                        print address for ldc/stc/ldf/stf instruction
107 4b0f1a8b pbrook
   %B                        print vstm/vldm register list
108 4b0f1a8b pbrook
   %C                        print vstr/vldr address operand
109 4b0f1a8b pbrook
   %I                   print cirrus signed shift immediate: bits 0..3|4..6
110 4b0f1a8b pbrook
   %F                        print the COUNT field of a LFM/SFM instruction.
111 4b0f1a8b pbrook
   %P                        print floating point precision in arithmetic insn
112 4b0f1a8b pbrook
   %Q                        print floating point precision in ldf/stf insn
113 4b0f1a8b pbrook
   %R                        print floating point rounding mode
114 4b0f1a8b pbrook

115 4b0f1a8b pbrook
   %<bitfield>r                print as an ARM register
116 aa0aa4fa bellard
   %<bitfield>d                print the bitfield in decimal
117 4b0f1a8b pbrook
   %<bitfield>k                print immediate for VFPv3 conversion instruction
118 aa0aa4fa bellard
   %<bitfield>x                print the bitfield in hex
119 aa0aa4fa bellard
   %<bitfield>X                print the bitfield as 1 hex digit without leading "0x"
120 aa0aa4fa bellard
   %<bitfield>f                print a floating point constant if >7 else a
121 aa0aa4fa bellard
                        floating point register
122 4b0f1a8b pbrook
   %<bitfield>w         print as an iWMMXt width field - [bhwd]ss/us
123 4b0f1a8b pbrook
   %<bitfield>g         print as an iWMMXt 64-bit register
124 4b0f1a8b pbrook
   %<bitfield>G         print as an iWMMXt general purpose or control register
125 4b0f1a8b pbrook
   %<bitfield>D                print as a NEON D register
126 4b0f1a8b pbrook
   %<bitfield>Q                print as a NEON Q register
127 4b0f1a8b pbrook

128 4b0f1a8b pbrook
   %y<code>                print a single precision VFP reg.
129 aa0aa4fa bellard
                          Codes: 0=>Sm, 1=>Sd, 2=>Sn, 3=>multi-list, 4=>Sm pair
130 4b0f1a8b pbrook
   %z<code>                print a double precision VFP reg
131 aa0aa4fa bellard
                          Codes: 0=>Dm, 1=>Dd, 2=>Dn, 3=>multi-list
132 4b0f1a8b pbrook

133 4b0f1a8b pbrook
   %<bitfield>'c        print specified char iff bitfield is all ones
134 4b0f1a8b pbrook
   %<bitfield>`c        print specified char iff bitfield is all zeroes
135 4b0f1a8b pbrook
   %<bitfield>?ab...    select from array of values in big endian order
136 4b0f1a8b pbrook

137 4b0f1a8b pbrook
   %L                        print as an iWMMXt N/M width field.
138 4b0f1a8b pbrook
   %Z                        print the Immediate of a WSHUFH instruction.
139 4b0f1a8b pbrook
   %l                        like 'A' except use byte offsets for 'B' & 'H'
140 4b0f1a8b pbrook
                        versions.
141 4b0f1a8b pbrook
   %i                        print 5-bit immediate in bits 8,3..0
142 4b0f1a8b pbrook
                        (print "32" when 0)
143 4b0f1a8b pbrook
   %r                        print register offset address for wldt/wstr instruction
144 4b0f1a8b pbrook
*/
145 4b0f1a8b pbrook
146 4b0f1a8b pbrook
/* Common coprocessor opcodes shared between Arm and Thumb-2.  */
147 4b0f1a8b pbrook
148 4b0f1a8b pbrook
static const struct opcode32 coprocessor_opcodes[] =
149 4b0f1a8b pbrook
{
150 4b0f1a8b pbrook
  /* XScale instructions.  */
151 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0ff0, "mia%c\tacc0, %0-3r, %12-15r"},
152 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0ff0, "miaph%c\tacc0, %0-3r, %12-15r"},
153 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0ff0, "mia%17'T%17`B%16'T%16`B%c\tacc0, %0-3r, %12-15r"},
154 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00fff, "mar%c\tacc0, %12-15r, %16-19r"},
155 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00fff, "mra%c\t%12-15r, %16-19r, acc0"},
156 4b0f1a8b pbrook
157 4b0f1a8b pbrook
  /* Intel Wireless MMX technology instructions.  */
158 4b0f1a8b pbrook
#define FIRST_IWMMXT_INSN 0x0e130130
159 4b0f1a8b pbrook
#define IWMMXT_INSN_COUNT 73
160 4b0f1a8b pbrook
  {ARM_CEXT_IWMMXT, 0x0e130130, 0x0f3f0fff, "tandc%22-23w%c\t%12-15r"},
161 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e400010, 0x0ff00f3f, "tbcst%6-7w%c\t%16-19g, %12-15r"},
162 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e130170, 0x0f3f0ff8, "textrc%22-23w%c\t%12-15r, #%0-2d"},
163 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100070, 0x0f300ff0, "textrm%3?su%22-23w%c\t%12-15r, %16-19g, #%0-2d"},
164 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e600010, 0x0ff00f38, "tinsr%6-7w%c\t%16-19g, %12-15r, #%0-2d"},
165 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000110, 0x0ff00fff, "tmcr%c\t%16-19G, %12-15r"},
166 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00ff0, "tmcrr%c\t%0-3g, %12-15r, %16-19r"},
167 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0e10, "tmia%17?tb%16?tb%c\t%5-8g, %0-3r, %12-15r"},
168 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0e10, "tmia%c\t%5-8g, %0-3r, %12-15r"},
169 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0e10, "tmiaph%c\t%5-8g, %0-3r, %12-15r"},
170 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100030, 0x0f300fff, "tmovmsk%22-23w%c\t%12-15r, %16-19g"},
171 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100110, 0x0ff00ff0, "tmrc%c\t%12-15r, %16-19G"},
172 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00ff0, "tmrrc%c\t%12-15r, %16-19r, %0-3g"},
173 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e130150, 0x0f3f0fff, "torc%22-23w%c\t%12-15r"},
174 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e130190, 0x0f3f0fff, "torvsc%22-23w%c\t%12-15r"},
175 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e2001c0, 0x0f300fff, "wabs%22-23w%c\t%12-15g, %16-19g"},
176 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0001c0, 0x0f300fff, "wacc%22-23w%c\t%12-15g, %16-19g"},
177 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000180, 0x0f000ff0, "wadd%20-23w%c\t%12-15g, %16-19g, %0-3g"},
178 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e2001a0, 0x0f300ff0, "waddbhus%22?ml%c\t%12-15g, %16-19g, %0-3g"},
179 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ea001a0, 0x0ff00ff0, "waddsubhx%c\t%12-15g, %16-19g, %0-3g"},
180 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000020, 0x0f800ff0, "waligni%c\t%12-15g, %16-19g, %0-3g, #%20-22d"},
181 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e800020, 0x0fc00ff0, "walignr%20-21d%c\t%12-15g, %16-19g, %0-3g"},
182 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e200000, 0x0fe00ff0, "wand%20'n%c\t%12-15g, %16-19g, %0-3g"},
183 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e800000, 0x0fa00ff0, "wavg2%22?hb%20'r%c\t%12-15g, %16-19g, %0-3g"},
184 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e400000, 0x0fe00ff0, "wavg4%20'r%c\t%12-15g, %16-19g, %0-3g"},
185 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000060, 0x0f300ff0, "wcmpeq%22-23w%c\t%12-15g, %16-19g, %0-3g"},
186 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100060, 0x0f100ff0, "wcmpgt%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
187 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfc500100, 0xfe500f00, "wldrd\t%12-15g, %r"},
188 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfc100100, 0xfe500f00, "wldrw\t%12-15G, %A"},
189 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c100000, 0x0e100e00, "wldr%L%c\t%12-15g, %l"},
190 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e400100, 0x0fc00ff0, "wmac%21?su%20'z%c\t%12-15g, %16-19g, %0-3g"},
191 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e800100, 0x0fc00ff0, "wmadd%21?su%20'x%c\t%12-15g, %16-19g, %0-3g"},
192 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ec00100, 0x0fd00ff0, "wmadd%21?sun%c\t%12-15g, %16-19g, %0-3g"},
193 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000160, 0x0f100ff0, "wmax%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
194 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000080, 0x0f100fe0, "wmerge%c\t%12-15g, %16-19g, %0-3g, #%21-23d"},
195 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0000a0, 0x0f800ff0, "wmia%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
196 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e800120, 0x0f800ff0, "wmiaw%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
197 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100160, 0x0f100ff0, "wmin%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
198 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000100, 0x0fc00ff0, "wmul%21?su%20?ml%23'r%c\t%12-15g, %16-19g, %0-3g"},
199 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ed00100, 0x0fd00ff0, "wmul%21?sumr%c\t%12-15g, %16-19g, %0-3g"},
200 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ee000c0, 0x0fe00ff0, "wmulwsm%20`r%c\t%12-15g, %16-19g, %0-3g"},
201 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ec000c0, 0x0fe00ff0, "wmulwum%20`r%c\t%12-15g, %16-19g, %0-3g"},
202 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0eb000c0, 0x0ff00ff0, "wmulwl%c\t%12-15g, %16-19g, %0-3g"},
203 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e8000a0, 0x0f800ff0, "wqmia%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
204 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100080, 0x0fd00ff0, "wqmulm%21'r%c\t%12-15g, %16-19g, %0-3g"},
205 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ec000e0, 0x0fd00ff0, "wqmulwm%21'r%c\t%12-15g, %16-19g, %0-3g"},
206 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000000, 0x0ff00ff0, "wor%c\t%12-15g, %16-19g, %0-3g"},
207 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000080, 0x0f000ff0, "wpack%20-23w%c\t%12-15g, %16-19g, %0-3g"},
208 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfe300040, 0xff300ef0, "wror%22-23w\t%12-15g, %16-19g, #%i"},
209 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e300040, 0x0f300ff0, "wror%22-23w%c\t%12-15g, %16-19g, %0-3g"},
210 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e300140, 0x0f300ff0, "wror%22-23wg%c\t%12-15g, %16-19g, %0-3G"},
211 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000120, 0x0fa00ff0, "wsad%22?hb%20'z%c\t%12-15g, %16-19g, %0-3g"},
212 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0001e0, 0x0f000ff0, "wshufh%c\t%12-15g, %16-19g, #%Z"},
213 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfe100040, 0xff300ef0, "wsll%22-23w\t%12-15g, %16-19g, #%i"},
214 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100040, 0x0f300ff0, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
215 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100148, 0x0f300ffc, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
216 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfe000040, 0xff300ef0, "wsra%22-23w\t%12-15g, %16-19g, #%i"},
217 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000040, 0x0f300ff0, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
218 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e000148, 0x0f300ffc, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
219 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfe200040, 0xff300ef0, "wsrl%22-23w\t%12-15g, %16-19g, #%i"},
220 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e200040, 0x0f300ff0, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
221 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e200148, 0x0f300ffc, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
222 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfc400100, 0xfe500f00, "wstrd\t%12-15g, %r"},
223 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0xfc000100, 0xfe500f00, "wstrw\t%12-15G, %A"},
224 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0c000000, 0x0e100e00, "wstr%L%c\t%12-15g, %l"},
225 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0001a0, 0x0f000ff0, "wsub%20-23w%c\t%12-15g, %16-19g, %0-3g"},
226 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0ed001c0, 0x0ff00ff0, "wsubaddhx%c\t%12-15g, %16-19g, %0-3g"},
227 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e1001c0, 0x0f300ff0, "wabsdiff%22-23w%c\t%12-15g, %16-19g, %0-3g"},
228 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0000c0, 0x0fd00fff, "wunpckeh%21?sub%c\t%12-15g, %16-19g"},
229 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e4000c0, 0x0fd00fff, "wunpckeh%21?suh%c\t%12-15g, %16-19g"},
230 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e8000c0, 0x0fd00fff, "wunpckeh%21?suw%c\t%12-15g, %16-19g"},
231 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e0000e0, 0x0f100fff, "wunpckel%21?su%22-23w%c\t%12-15g, %16-19g"},
232 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e1000c0, 0x0f300ff0, "wunpckih%22-23w%c\t%12-15g, %16-19g, %0-3g"},
233 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e1000e0, 0x0f300ff0, "wunpckil%22-23w%c\t%12-15g, %16-19g, %0-3g"},
234 4b0f1a8b pbrook
  {ARM_CEXT_XSCALE, 0x0e100000, 0x0ff00ff0, "wxor%c\t%12-15g, %16-19g, %0-3g"},
235 4b0f1a8b pbrook
236 4b0f1a8b pbrook
  /* Floating point coprocessor (FPA) instructions */
237 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e000100, 0x0ff08f10, "adf%c%P%R\t%12-14f, %16-18f, %0-3f"},
238 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e100100, 0x0ff08f10, "muf%c%P%R\t%12-14f, %16-18f, %0-3f"},
239 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e200100, 0x0ff08f10, "suf%c%P%R\t%12-14f, %16-18f, %0-3f"},
240 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e300100, 0x0ff08f10, "rsf%c%P%R\t%12-14f, %16-18f, %0-3f"},
241 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e400100, 0x0ff08f10, "dvf%c%P%R\t%12-14f, %16-18f, %0-3f"},
242 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e500100, 0x0ff08f10, "rdf%c%P%R\t%12-14f, %16-18f, %0-3f"},
243 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e600100, 0x0ff08f10, "pow%c%P%R\t%12-14f, %16-18f, %0-3f"},
244 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e700100, 0x0ff08f10, "rpw%c%P%R\t%12-14f, %16-18f, %0-3f"},
245 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e800100, 0x0ff08f10, "rmf%c%P%R\t%12-14f, %16-18f, %0-3f"},
246 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e900100, 0x0ff08f10, "fml%c%P%R\t%12-14f, %16-18f, %0-3f"},
247 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ea00100, 0x0ff08f10, "fdv%c%P%R\t%12-14f, %16-18f, %0-3f"},
248 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0eb00100, 0x0ff08f10, "frd%c%P%R\t%12-14f, %16-18f, %0-3f"},
249 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ec00100, 0x0ff08f10, "pol%c%P%R\t%12-14f, %16-18f, %0-3f"},
250 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e008100, 0x0ff08f10, "mvf%c%P%R\t%12-14f, %0-3f"},
251 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e108100, 0x0ff08f10, "mnf%c%P%R\t%12-14f, %0-3f"},
252 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e208100, 0x0ff08f10, "abs%c%P%R\t%12-14f, %0-3f"},
253 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e308100, 0x0ff08f10, "rnd%c%P%R\t%12-14f, %0-3f"},
254 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e408100, 0x0ff08f10, "sqt%c%P%R\t%12-14f, %0-3f"},
255 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e508100, 0x0ff08f10, "log%c%P%R\t%12-14f, %0-3f"},
256 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e608100, 0x0ff08f10, "lgn%c%P%R\t%12-14f, %0-3f"},
257 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e708100, 0x0ff08f10, "exp%c%P%R\t%12-14f, %0-3f"},
258 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e808100, 0x0ff08f10, "sin%c%P%R\t%12-14f, %0-3f"},
259 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e908100, 0x0ff08f10, "cos%c%P%R\t%12-14f, %0-3f"},
260 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ea08100, 0x0ff08f10, "tan%c%P%R\t%12-14f, %0-3f"},
261 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0eb08100, 0x0ff08f10, "asn%c%P%R\t%12-14f, %0-3f"},
262 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ec08100, 0x0ff08f10, "acs%c%P%R\t%12-14f, %0-3f"},
263 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ed08100, 0x0ff08f10, "atn%c%P%R\t%12-14f, %0-3f"},
264 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ee08100, 0x0ff08f10, "urd%c%P%R\t%12-14f, %0-3f"},
265 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ef08100, 0x0ff08f10, "nrm%c%P%R\t%12-14f, %0-3f"},
266 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e000110, 0x0ff00f1f, "flt%c%P%R\t%16-18f, %12-15r"},
267 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e100110, 0x0fff0f98, "fix%c%R\t%12-15r, %0-2f"},
268 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e200110, 0x0fff0fff, "wfs%c\t%12-15r"},
269 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e300110, 0x0fff0fff, "rfs%c\t%12-15r"},
270 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e400110, 0x0fff0fff, "wfc%c\t%12-15r"},
271 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e500110, 0x0fff0fff, "rfc%c\t%12-15r"},
272 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0e90f110, 0x0ff8fff0, "cmf%c\t%16-18f, %0-3f"},
273 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0eb0f110, 0x0ff8fff0, "cnf%c\t%16-18f, %0-3f"},
274 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ed0f110, 0x0ff8fff0, "cmfe%c\t%16-18f, %0-3f"},
275 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0ef0f110, 0x0ff8fff0, "cnfe%c\t%16-18f, %0-3f"},
276 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0c000100, 0x0e100f00, "stf%c%Q\t%12-14f, %A"},
277 4b0f1a8b pbrook
  {FPU_FPA_EXT_V1, 0x0c100100, 0x0e100f00, "ldf%c%Q\t%12-14f, %A"},
278 4b0f1a8b pbrook
  {FPU_FPA_EXT_V2, 0x0c000200, 0x0e100f00, "sfm%c\t%12-14f, %F, %A"},
279 4b0f1a8b pbrook
  {FPU_FPA_EXT_V2, 0x0c100200, 0x0e100f00, "lfm%c\t%12-14f, %F, %A"},
280 4b0f1a8b pbrook
281 4b0f1a8b pbrook
  /* Register load/store */
282 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0d200b00, 0x0fb00f01, "vstmdb%c\t%16-19r%21'!, %B"},
283 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0d300b00, 0x0fb00f01, "vldmdb%c\t%16-19r%21'!, %B"},
284 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0c800b00, 0x0f900f01, "vstmia%c\t%16-19r%21'!, %B"},
285 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0c900b00, 0x0f900f01, "vldmia%c\t%16-19r%21'!, %B"},
286 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0d000b00, 0x0f300f00, "vstr%c\t%12-15,22D, %C"},
287 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0d100b00, 0x0f300f00, "vldr%c\t%12-15,22D, %C"},
288 4b0f1a8b pbrook
289 4b0f1a8b pbrook
  /* Data transfer between ARM and NEON registers */
290 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e800b10, 0x0ff00f70, "vdup%c.32\t%16-19,7D, %12-15r"},
291 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e800b30, 0x0ff00f70, "vdup%c.16\t%16-19,7D, %12-15r"},
292 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0ea00b10, 0x0ff00f70, "vdup%c.32\t%16-19,7Q, %12-15r"},
293 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0ea00b30, 0x0ff00f70, "vdup%c.16\t%16-19,7Q, %12-15r"},
294 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0ec00b10, 0x0ff00f70, "vdup%c.8\t%16-19,7D, %12-15r"},
295 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0ee00b10, 0x0ff00f70, "vdup%c.8\t%16-19,7Q, %12-15r"},
296 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0c400b10, 0x0ff00fd0, "vmov%c\t%0-3,5D, %12-15r, %16-19r"},
297 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0c500b10, 0x0ff00fd0, "vmov%c\t%12-15r, %16-19r, %0-3,5D"},
298 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e000b10, 0x0fd00f70, "vmov%c.32\t%16-19,7D[%21d], %12-15r"},
299 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e100b10, 0x0f500f70, "vmov%c.32\t%12-15r, %16-19,7D[%21d]"},
300 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e000b30, 0x0fd00f30, "vmov%c.16\t%16-19,7D[%6,21d], %12-15r"},
301 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e100b30, 0x0f500f30, "vmov%c.%23?us16\t%12-15r, %16-19,7D[%6,21d]"},
302 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e400b10, 0x0fd00f10, "vmov%c.8\t%16-19,7D[%5,6,21d], %12-15r"},
303 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0x0e500b10, 0x0f500f10, "vmov%c.%23?us8\t%12-15r, %16-19,7D[%5,6,21d]"},
304 4b0f1a8b pbrook
305 4b0f1a8b pbrook
  /* Floating point coprocessor (VFP) instructions */
306 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef1fa10, 0x0fffffff, "fmstat%c"},
307 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0fff0fff, "fmxr%c\tfpsid, %12-15r"},
308 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee10a10, 0x0fff0fff, "fmxr%c\tfpscr, %12-15r"},
309 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee60a10, 0x0fff0fff, "fmxr%c\tmvfr1, %12-15r"},
310 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee70a10, 0x0fff0fff, "fmxr%c\tmvfr0, %12-15r"},
311 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee80a10, 0x0fff0fff, "fmxr%c\tfpexc, %12-15r"},
312 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee90a10, 0x0fff0fff, "fmxr%c\tfpinst, %12-15r\t@ Impl def"},
313 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eea0a10, 0x0fff0fff, "fmxr%c\tfpinst2, %12-15r\t@ Impl def"},
314 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpsid"},
315 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef10a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpscr"},
316 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef60a10, 0x0fff0fff, "fmrx%c\t%12-15r, mvfr1"},
317 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef70a10, 0x0fff0fff, "fmrx%c\t%12-15r, mvfr0"},
318 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef80a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpexc"},
319 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef90a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst\t@ Impl def"},
320 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0efa0a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst2\t@ Impl def"},
321 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e000b10, 0x0ff00fff, "fmdlr%c\t%z2, %12-15r"},
322 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e100b10, 0x0ff00fff, "fmrdl%c\t%12-15r, %z2"},
323 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e200b10, 0x0ff00fff, "fmdhr%c\t%z2, %12-15r"},
324 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e300b10, 0x0ff00fff, "fmrdh%c\t%12-15r, %z2"},
325 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0ff00fff, "fmxr%c\t<impl def %16-19x>, %12-15r"},
326 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0ff00fff, "fmrx%c\t%12-15r, <impl def %16-19x>"},
327 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e000a10, 0x0ff00f7f, "fmsr%c\t%y2, %12-15r"},
328 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e100a10, 0x0ff00f7f, "fmrs%c\t%12-15r, %y2"},
329 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb50a40, 0x0fbf0f70, "fcmp%7'ezs%c\t%y1"},
330 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb50b40, 0x0fbf0f70, "fcmp%7'ezd%c\t%z1"},
331 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb00a40, 0x0fbf0fd0, "fcpys%c\t%y1, %y0"},
332 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb00ac0, 0x0fbf0fd0, "fabss%c\t%y1, %y0"},
333 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb00b40, 0x0fbf0fd0, "fcpyd%c\t%z1, %z0"},
334 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb00bc0, 0x0fbf0fd0, "fabsd%c\t%z1, %z0"},
335 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb10a40, 0x0fbf0fd0, "fnegs%c\t%y1, %y0"},
336 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb10ac0, 0x0fbf0fd0, "fsqrts%c\t%y1, %y0"},
337 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb10b40, 0x0fbf0fd0, "fnegd%c\t%z1, %z0"},
338 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb10bc0, 0x0fbf0fd0, "fsqrtd%c\t%z1, %z0"},
339 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb70ac0, 0x0fbf0fd0, "fcvtds%c\t%z1, %y0"},
340 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb70bc0, 0x0fbf0fd0, "fcvtsd%c\t%y1, %z0"},
341 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb80a40, 0x0fbf0fd0, "fuitos%c\t%y1, %y0"},
342 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb80ac0, 0x0fbf0fd0, "fsitos%c\t%y1, %y0"},
343 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb80b40, 0x0fbf0fd0, "fuitod%c\t%z1, %y0"},
344 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb80bc0, 0x0fbf0fd0, "fsitod%c\t%z1, %y0"},
345 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0eb40a40, 0x0fbf0f50, "fcmp%7'es%c\t%y1, %y0"},
346 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0eb40b40, 0x0fbf0f50, "fcmp%7'ed%c\t%z1, %z0"},
347 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0eba0a40, 0x0fbe0f50, "f%16?us%7?lhtos%c\t%y1, #%5,0-3k"},
348 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0eba0b40, 0x0fbe0f50, "f%16?us%7?lhtod%c\t%z1, #%5,0-3k"},
349 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0ebc0a40, 0x0fbe0f50, "fto%16?sui%7'zs%c\t%y1, %y0"},
350 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0ebc0b40, 0x0fbe0f50, "fto%16?sui%7'zd%c\t%y1, %z0"},
351 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0ebe0a40, 0x0fbe0f50, "fto%16?us%7?lhs%c\t%y1, #%5,0-3k"},
352 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0ebe0b40, 0x0fbe0f50, "fto%16?us%7?lhd%c\t%z1, #%5,0-3k"},
353 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0c500b10, 0x0fb00ff0, "fmrrd%c\t%12-15r, %16-19r, %z0"},
354 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0eb00a00, 0x0fb00ff0, "fconsts%c\t%y1, #%0-3,16-19d"},
355 4b0f1a8b pbrook
  {FPU_VFP_EXT_V3, 0x0eb00b00, 0x0fb00ff0, "fconstd%c\t%z1, #%0-3,16-19d"},
356 4b0f1a8b pbrook
  {FPU_VFP_EXT_V2, 0x0c400a10, 0x0ff00fd0, "fmsrr%c\t%y4, %12-15r, %16-19r"},
357 4b0f1a8b pbrook
  {FPU_VFP_EXT_V2, 0x0c400b10, 0x0ff00fd0, "fmdrr%c\t%z0, %12-15r, %16-19r"},
358 4b0f1a8b pbrook
  {FPU_VFP_EXT_V2, 0x0c500a10, 0x0ff00fd0, "fmrrs%c\t%12-15r, %16-19r, %y4"},
359 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e000a00, 0x0fb00f50, "fmacs%c\t%y1, %y2, %y0"},
360 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e000a40, 0x0fb00f50, "fnmacs%c\t%y1, %y2, %y0"},
361 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e000b00, 0x0fb00f50, "fmacd%c\t%z1, %z2, %z0"},
362 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e000b40, 0x0fb00f50, "fnmacd%c\t%z1, %z2, %z0"},
363 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e100a00, 0x0fb00f50, "fmscs%c\t%y1, %y2, %y0"},
364 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e100a40, 0x0fb00f50, "fnmscs%c\t%y1, %y2, %y0"},
365 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e100b00, 0x0fb00f50, "fmscd%c\t%z1, %z2, %z0"},
366 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e100b40, 0x0fb00f50, "fnmscd%c\t%z1, %z2, %z0"},
367 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e200a00, 0x0fb00f50, "fmuls%c\t%y1, %y2, %y0"},
368 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e200a40, 0x0fb00f50, "fnmuls%c\t%y1, %y2, %y0"},
369 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e200b00, 0x0fb00f50, "fmuld%c\t%z1, %z2, %z0"},
370 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e200b40, 0x0fb00f50, "fnmuld%c\t%z1, %z2, %z0"},
371 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e300a00, 0x0fb00f50, "fadds%c\t%y1, %y2, %y0"},
372 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e300a40, 0x0fb00f50, "fsubs%c\t%y1, %y2, %y0"},
373 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e300b00, 0x0fb00f50, "faddd%c\t%z1, %z2, %z0"},
374 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e300b40, 0x0fb00f50, "fsubd%c\t%z1, %z2, %z0"},
375 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0e800a00, 0x0fb00f50, "fdivs%c\t%y1, %y2, %y0"},
376 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0e800b00, 0x0fb00f50, "fdivd%c\t%z1, %z2, %z0"},
377 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d200a00, 0x0fb00f00, "fstmdbs%c\t%16-19r!, %y3"},
378 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d200b00, 0x0fb00f00, "fstmdb%0?xd%c\t%16-19r!, %z3"},
379 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d300a00, 0x0fb00f00, "fldmdbs%c\t%16-19r!, %y3"},
380 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d300b00, 0x0fb00f00, "fldmdb%0?xd%c\t%16-19r!, %z3"},
381 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d000a00, 0x0f300f00, "fsts%c\t%y1, %A"},
382 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0d000b00, 0x0f300f00, "fstd%c\t%z1, %A"},
383 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0d100a00, 0x0f300f00, "flds%c\t%y1, %A"},
384 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1, 0x0d100b00, 0x0f300f00, "fldd%c\t%z1, %A"},
385 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0c800a00, 0x0f900f00, "fstmias%c\t%16-19r%21'!, %y3"},
386 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0c800b00, 0x0f900f00, "fstmia%0?xd%c\t%16-19r%21'!, %z3"},
387 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0c900a00, 0x0f900f00, "fldmias%c\t%16-19r%21'!, %y3"},
388 4b0f1a8b pbrook
  {FPU_VFP_EXT_V1xD, 0x0c900b00, 0x0f900f00, "fldmia%0?xd%c\t%16-19r%21'!, %z3"},
389 4b0f1a8b pbrook
390 4b0f1a8b pbrook
  /* Cirrus coprocessor instructions.  */
391 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
392 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
393 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
394 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
395 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
396 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
397 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
398 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
399 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
400 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
401 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
402 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
403 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
404 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
405 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0d400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
406 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0c400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
407 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000450, 0x0ff00ff0, "cfmvsr%c\tmvf%16-19d, %12-15r"},
408 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100450, 0x0ff00ff0, "cfmvrs%c\t%12-15r, mvf%16-19d"},
409 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000410, 0x0ff00ff0, "cfmvdlr%c\tmvd%16-19d, %12-15r"},
410 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100410, 0x0ff00ff0, "cfmvrdl%c\t%12-15r, mvd%16-19d"},
411 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000430, 0x0ff00ff0, "cfmvdhr%c\tmvd%16-19d, %12-15r"},
412 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100430, 0x0ff00fff, "cfmvrdh%c\t%12-15r, mvd%16-19d"},
413 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000510, 0x0ff00fff, "cfmv64lr%c\tmvdx%16-19d, %12-15r"},
414 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100510, 0x0ff00fff, "cfmvr64l%c\t%12-15r, mvdx%16-19d"},
415 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000530, 0x0ff00fff, "cfmv64hr%c\tmvdx%16-19d, %12-15r"},
416 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100530, 0x0ff00fff, "cfmvr64h%c\t%12-15r, mvdx%16-19d"},
417 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e200440, 0x0ff00fff, "cfmval32%c\tmvax%12-15d, mvfx%16-19d"},
418 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100440, 0x0ff00fff, "cfmv32al%c\tmvfx%12-15d, mvax%16-19d"},
419 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e200460, 0x0ff00fff, "cfmvam32%c\tmvax%12-15d, mvfx%16-19d"},
420 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100460, 0x0ff00fff, "cfmv32am%c\tmvfx%12-15d, mvax%16-19d"},
421 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e200480, 0x0ff00fff, "cfmvah32%c\tmvax%12-15d, mvfx%16-19d"},
422 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100480, 0x0ff00fff, "cfmv32ah%c\tmvfx%12-15d, mvax%16-19d"},
423 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e2004a0, 0x0ff00fff, "cfmva32%c\tmvax%12-15d, mvfx%16-19d"},
424 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1004a0, 0x0ff00fff, "cfmv32a%c\tmvfx%12-15d, mvax%16-19d"},
425 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e2004c0, 0x0ff00fff, "cfmva64%c\tmvax%12-15d, mvdx%16-19d"},
426 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1004c0, 0x0ff00fff, "cfmv64a%c\tmvdx%12-15d, mvax%16-19d"},
427 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e2004e0, 0x0fff0fff, "cfmvsc32%c\tdspsc, mvdx%12-15d"},
428 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1004e0, 0x0fff0fff, "cfmv32sc%c\tmvdx%12-15d, dspsc"},
429 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000400, 0x0ff00fff, "cfcpys%c\tmvf%12-15d, mvf%16-19d"},
430 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000420, 0x0ff00fff, "cfcpyd%c\tmvd%12-15d, mvd%16-19d"},
431 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000460, 0x0ff00fff, "cfcvtsd%c\tmvd%12-15d, mvf%16-19d"},
432 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000440, 0x0ff00fff, "cfcvtds%c\tmvf%12-15d, mvd%16-19d"},
433 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000480, 0x0ff00fff, "cfcvt32s%c\tmvf%12-15d, mvfx%16-19d"},
434 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e0004a0, 0x0ff00fff, "cfcvt32d%c\tmvd%12-15d, mvfx%16-19d"},
435 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e0004c0, 0x0ff00fff, "cfcvt64s%c\tmvf%12-15d, mvdx%16-19d"},
436 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e0004e0, 0x0ff00fff, "cfcvt64d%c\tmvd%12-15d, mvdx%16-19d"},
437 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100580, 0x0ff00fff, "cfcvts32%c\tmvfx%12-15d, mvf%16-19d"},
438 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1005a0, 0x0ff00fff, "cfcvtd32%c\tmvfx%12-15d, mvd%16-19d"},
439 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1005c0, 0x0ff00fff, "cftruncs32%c\tmvfx%12-15d, mvf%16-19d"},
440 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1005e0, 0x0ff00fff, "cftruncd32%c\tmvfx%12-15d, mvd%16-19d"},
441 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000550, 0x0ff00ff0, "cfrshl32%c\tmvfx%16-19d, mvfx%0-3d, %12-15r"},
442 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000570, 0x0ff00ff0, "cfrshl64%c\tmvdx%16-19d, mvdx%0-3d, %12-15r"},
443 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000500, 0x0ff00f10, "cfsh32%c\tmvfx%12-15d, mvfx%16-19d, #%I"},
444 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e200500, 0x0ff00f10, "cfsh64%c\tmvdx%12-15d, mvdx%16-19d, #%I"},
445 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100490, 0x0ff00ff0, "cfcmps%c\t%12-15r, mvf%16-19d, mvf%0-3d"},
446 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1004b0, 0x0ff00ff0, "cfcmpd%c\t%12-15r, mvd%16-19d, mvd%0-3d"},
447 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100590, 0x0ff00ff0, "cfcmp32%c\t%12-15r, mvfx%16-19d, mvfx%0-3d"},
448 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e1005b0, 0x0ff00ff0, "cfcmp64%c\t%12-15r, mvdx%16-19d, mvdx%0-3d"},
449 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300400, 0x0ff00fff, "cfabss%c\tmvf%12-15d, mvf%16-19d"},
450 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300420, 0x0ff00fff, "cfabsd%c\tmvd%12-15d, mvd%16-19d"},
451 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300440, 0x0ff00fff, "cfnegs%c\tmvf%12-15d, mvf%16-19d"},
452 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300460, 0x0ff00fff, "cfnegd%c\tmvd%12-15d, mvd%16-19d"},
453 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300480, 0x0ff00ff0, "cfadds%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
454 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3004a0, 0x0ff00ff0, "cfaddd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
455 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3004c0, 0x0ff00ff0, "cfsubs%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
456 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3004e0, 0x0ff00ff0, "cfsubd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
457 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100400, 0x0ff00ff0, "cfmuls%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
458 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100420, 0x0ff00ff0, "cfmuld%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
459 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300500, 0x0ff00fff, "cfabs32%c\tmvfx%12-15d, mvfx%16-19d"},
460 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300520, 0x0ff00fff, "cfabs64%c\tmvdx%12-15d, mvdx%16-19d"},
461 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300540, 0x0ff00fff, "cfneg32%c\tmvfx%12-15d, mvfx%16-19d"},
462 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300560, 0x0ff00fff, "cfneg64%c\tmvdx%12-15d, mvdx%16-19d"},
463 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300580, 0x0ff00ff0, "cfadd32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
464 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3005a0, 0x0ff00ff0, "cfadd64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
465 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3005c0, 0x0ff00ff0, "cfsub32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
466 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e3005e0, 0x0ff00ff0, "cfsub64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
467 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100500, 0x0ff00ff0, "cfmul32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
468 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100520, 0x0ff00ff0, "cfmul64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
469 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100540, 0x0ff00ff0, "cfmac32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
470 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100560, 0x0ff00ff0, "cfmsc32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
471 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e000600, 0x0ff00f10, "cfmadd32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
472 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e100600, 0x0ff00f10, "cfmsub32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
473 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e200600, 0x0ff00f10, "cfmadda32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
474 4b0f1a8b pbrook
  {ARM_CEXT_MAVERICK, 0x0e300600, 0x0ff00f10, "cfmsuba32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
475 4b0f1a8b pbrook
476 4b0f1a8b pbrook
  /* Generic coprocessor instructions */
477 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0c400000, 0x0ff00000, "mcrr%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
478 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0c500000, 0x0ff00000, "mrrc%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
479 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0e000000, 0x0f000010, "cdp%c\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
480 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0e100010, 0x0f100010, "mrc%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
481 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0e000010, 0x0f100010, "mcr%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
482 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0c000000, 0x0e100000, "stc%22'l%c\t%8-11d, cr%12-15d, %A"},
483 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x0c100000, 0x0e100000, "ldc%22'l%c\t%8-11d, cr%12-15d, %A"},
484 4b0f1a8b pbrook
485 4b0f1a8b pbrook
  /* V6 coprocessor instructions */
486 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xfc500000, 0xfff00000, "mrrc2%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
487 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xfc400000, 0xfff00000, "mcrr2%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
488 4b0f1a8b pbrook
489 4b0f1a8b pbrook
  /* V5 coprocessor instructions */
490 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfc100000, 0xfe100000, "ldc2%22'l%c\t%8-11d, cr%12-15d, %A"},
491 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfc000000, 0xfe100000, "stc2%22'l%c\t%8-11d, cr%12-15d, %A"},
492 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfe000000, 0xff000010, "cdp2%c\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
493 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfe000010, 0xff100010, "mcr2%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
494 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfe100010, 0xff100010, "mrc2%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
495 4b0f1a8b pbrook
496 4b0f1a8b pbrook
  {0, 0, 0, 0}
497 4b0f1a8b pbrook
};
498 4b0f1a8b pbrook
499 4b0f1a8b pbrook
/* Neon opcode table:  This does not encode the top byte -- that is
500 4b0f1a8b pbrook
   checked by the print_insn_neon routine, as it depends on whether we are
501 4b0f1a8b pbrook
   doing thumb32 or arm32 disassembly.  */
502 4b0f1a8b pbrook
503 4b0f1a8b pbrook
/* print_insn_neon recognizes the following format control codes:
504 4b0f1a8b pbrook

505 4b0f1a8b pbrook
   %%                        %
506 4b0f1a8b pbrook

507 4b0f1a8b pbrook
   %c                        print condition code
508 4b0f1a8b pbrook
   %A                        print v{st,ld}[1234] operands
509 4b0f1a8b pbrook
   %B                        print v{st,ld}[1234] any one operands
510 4b0f1a8b pbrook
   %C                        print v{st,ld}[1234] single->all operands
511 4b0f1a8b pbrook
   %D                        print scalar
512 4b0f1a8b pbrook
   %E                        print vmov, vmvn, vorr, vbic encoded constant
513 4b0f1a8b pbrook
   %F                        print vtbl,vtbx register list
514 4b0f1a8b pbrook

515 4b0f1a8b pbrook
   %<bitfield>r                print as an ARM register
516 4b0f1a8b pbrook
   %<bitfield>d                print the bitfield in decimal
517 4b0f1a8b pbrook
   %<bitfield>e         print the 2^N - bitfield in decimal
518 4b0f1a8b pbrook
   %<bitfield>D                print as a NEON D register
519 4b0f1a8b pbrook
   %<bitfield>Q                print as a NEON Q register
520 4b0f1a8b pbrook
   %<bitfield>R                print as a NEON D or Q register
521 4b0f1a8b pbrook
   %<bitfield>Sn        print byte scaled width limited by n
522 4b0f1a8b pbrook
   %<bitfield>Tn        print short scaled width limited by n
523 4b0f1a8b pbrook
   %<bitfield>Un        print long scaled width limited by n
524 4b0f1a8b pbrook

525 4b0f1a8b pbrook
   %<bitfield>'c        print specified char iff bitfield is all ones
526 4b0f1a8b pbrook
   %<bitfield>`c        print specified char iff bitfield is all zeroes
527 4b0f1a8b pbrook
   %<bitfield>?ab...    select from array of values in big endian order  */
528 4b0f1a8b pbrook
529 4b0f1a8b pbrook
static const struct opcode32 neon_opcodes[] =
530 4b0f1a8b pbrook
{
531 4b0f1a8b pbrook
  /* Extract */
532 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2b00840, 0xffb00850, "vext%c.8\t%12-15,22R, %16-19,7R, %0-3,5R, #%8-11d"},
533 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2b00000, 0xffb00810, "vext%c.8\t%12-15,22R, %16-19,7R, %0-3,5R, #%8-11d"},
534 4b0f1a8b pbrook
535 4b0f1a8b pbrook
  /* Move data element to all lanes */
536 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b40c00, 0xffb70f90, "vdup%c.32\t%12-15,22R, %0-3,5D[%19d]"},
537 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20c00, 0xffb30f90, "vdup%c.16\t%12-15,22R, %0-3,5D[%18-19d]"},
538 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10c00, 0xffb10f90, "vdup%c.8\t%12-15,22R, %0-3,5D[%17-19d]"},
539 4b0f1a8b pbrook
540 4b0f1a8b pbrook
  /* Table lookup */
541 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00800, 0xffb00c50, "vtbl%c.8\t%12-15,22D, %F, %0-3,5D"},
542 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00840, 0xffb00c50, "vtbx%c.8\t%12-15,22D, %F, %0-3,5D"},
543 4b0f1a8b pbrook
544 4b0f1a8b pbrook
  /* Two registers, miscellaneous */
545 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880a10, 0xfebf0fd0, "vmovl%c.%24?us8\t%12-15,22Q, %0-3,5D"},
546 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900a10, 0xfebf0fd0, "vmovl%c.%24?us16\t%12-15,22Q, %0-3,5D"},
547 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00a10, 0xfebf0fd0, "vmovl%c.%24?us32\t%12-15,22Q, %0-3,5D"},
548 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00500, 0xffbf0f90, "vcnt%c.8\t%12-15,22R, %0-3,5R"},
549 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00580, 0xffbf0f90, "vmvn%c\t%12-15,22R, %0-3,5R"},
550 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20000, 0xffbf0f90, "vswp%c\t%12-15,22R, %0-3,5R"},
551 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20200, 0xffb30fd0, "vmovn%c.i%18-19T2\t%12-15,22D, %0-3,5Q"},
552 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20240, 0xffb30fd0, "vqmovun%c.s%18-19T2\t%12-15,22D, %0-3,5Q"},
553 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20280, 0xffb30fd0, "vqmovn%c.s%18-19T2\t%12-15,22D, %0-3,5Q"},
554 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b202c0, 0xffb30fd0, "vqmovn%c.u%18-19T2\t%12-15,22D, %0-3,5Q"},
555 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20300, 0xffb30fd0, "vshll%c.i%18-19S2\t%12-15,22Q, %0-3,5D, #%18-19S2"},
556 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3bb0400, 0xffbf0e90, "vrecpe%c.%8?fu%18-19S2\t%12-15,22R, %0-3,5R"},
557 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3bb0480, 0xffbf0e90, "vrsqrte%c.%8?fu%18-19S2\t%12-15,22R, %0-3,5R"},
558 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00000, 0xffb30f90, "vrev64%c.%18-19S2\t%12-15,22R, %0-3,5R"},
559 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00080, 0xffb30f90, "vrev32%c.%18-19S2\t%12-15,22R, %0-3,5R"},
560 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00100, 0xffb30f90, "vrev16%c.%18-19S2\t%12-15,22R, %0-3,5R"},
561 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00400, 0xffb30f90, "vcls%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
562 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00480, 0xffb30f90, "vclz%c.i%18-19S2\t%12-15,22R, %0-3,5R"},
563 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00700, 0xffb30f90, "vqabs%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
564 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00780, 0xffb30f90, "vqneg%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
565 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20080, 0xffb30f90, "vtrn%c.%18-19S2\t%12-15,22R, %0-3,5R"},
566 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20100, 0xffb30f90, "vuzp%c.%18-19S2\t%12-15,22R, %0-3,5R"},
567 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b20180, 0xffb30f90, "vzip%c.%18-19S2\t%12-15,22R, %0-3,5R"},
568 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10000, 0xffb30b90, "vcgt%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
569 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10080, 0xffb30b90, "vcge%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
570 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10100, 0xffb30b90, "vceq%c.%10?fi%18-19S2\t%12-15,22R, %0-3,5R, #0"},
571 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10180, 0xffb30b90, "vcle%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
572 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10200, 0xffb30b90, "vclt%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
573 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10300, 0xffb30b90, "vabs%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R"},
574 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b10380, 0xffb30b90, "vneg%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R"},
575 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00200, 0xffb30f10, "vpaddl%c.%7?us%18-19S2\t%12-15,22R, %0-3,5R"},
576 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b00600, 0xffb30f10, "vpadal%c.%7?us%18-19S2\t%12-15,22R, %0-3,5R"},
577 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3b30600, 0xffb30e10, "vcvt%c.%7-8?usff%18-19Sa.%7-8?ffus%18-19Sa\t%12-15,22R, %0-3,5R"},
578 4b0f1a8b pbrook
579 4b0f1a8b pbrook
  /* Three registers of the same length */
580 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000110, 0xffb00f10, "vand%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
581 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2100110, 0xffb00f10, "vbic%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
582 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2200110, 0xffb00f10, "vorr%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
583 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2300110, 0xffb00f10, "vorn%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
584 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000110, 0xffb00f10, "veor%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
585 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3100110, 0xffb00f10, "vbsl%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
586 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3200110, 0xffb00f10, "vbit%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
587 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3300110, 0xffb00f10, "vbif%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
588 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000d00, 0xffa00f10, "vadd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
589 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000d10, 0xffa00f10, "vmla%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
590 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000e00, 0xffa00f10, "vceq%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
591 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000f00, 0xffa00f10, "vmax%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
592 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000f10, 0xffa00f10, "vrecps%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
593 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2200d00, 0xffa00f10, "vsub%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
594 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2200d10, 0xffa00f10, "vmls%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
595 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2200f00, 0xffa00f10, "vmin%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
596 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2200f10, 0xffa00f10, "vrsqrts%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
597 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000d00, 0xffa00f10, "vpadd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
598 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000d10, 0xffa00f10, "vmul%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
599 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000e00, 0xffa00f10, "vcge%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
600 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000e10, 0xffa00f10, "vacge%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
601 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000f00, 0xffa00f10, "vpmax%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
602 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3200d00, 0xffa00f10, "vabd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
603 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3200e00, 0xffa00f10, "vcgt%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
604 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3200e10, 0xffa00f10, "vacgt%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
605 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3200f00, 0xffa00f10, "vpmin%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
606 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000800, 0xff800f10, "vadd%c.i%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
607 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000810, 0xff800f10, "vtst%c.%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
608 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000900, 0xff800f10, "vmla%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
609 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000b00, 0xff800f10, "vqdmulh%c.s%20-21S6\t%12-15,22R, %16-19,7R, %0-3,5R"},
610 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000b10, 0xff800f10, "vpadd%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
611 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000800, 0xff800f10, "vsub%c.i%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
612 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000810, 0xff800f10, "vceq%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
613 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000900, 0xff800f10, "vmls%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
614 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3000b00, 0xff800f10, "vqrdmulh%c.s%20-21S6\t%12-15,22R, %16-19,7R, %0-3,5R"},
615 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000000, 0xfe800f10, "vhadd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
616 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000010, 0xfe800f10, "vqadd%c.%24?us%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
617 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000100, 0xfe800f10, "vrhadd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
618 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000200, 0xfe800f10, "vhsub%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
619 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000210, 0xfe800f10, "vqsub%c.%24?us%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
620 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000300, 0xfe800f10, "vcgt%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
621 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000310, 0xfe800f10, "vcge%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
622 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000400, 0xfe800f10, "vshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
623 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000410, 0xfe800f10, "vqshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
624 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000500, 0xfe800f10, "vrshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
625 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000510, 0xfe800f10, "vqrshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
626 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000600, 0xfe800f10, "vmax%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
627 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000610, 0xfe800f10, "vmin%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
628 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000700, 0xfe800f10, "vabd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
629 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000710, 0xfe800f10, "vaba%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
630 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000910, 0xfe800f10, "vmul%c.%24?pi%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
631 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000a00, 0xfe800f10, "vpmax%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
632 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2000a10, 0xfe800f10, "vpmin%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
633 4b0f1a8b pbrook
634 4b0f1a8b pbrook
  /* One register and an immediate value */
635 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800e10, 0xfeb80fb0, "vmov%c.i8\t%12-15,22R, %E"},
636 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800e30, 0xfeb80fb0, "vmov%c.i64\t%12-15,22R, %E"},
637 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800f10, 0xfeb80fb0, "vmov%c.f32\t%12-15,22R, %E"},
638 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800810, 0xfeb80db0, "vmov%c.i16\t%12-15,22R, %E"},
639 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800830, 0xfeb80db0, "vmvn%c.i16\t%12-15,22R, %E"},
640 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800910, 0xfeb80db0, "vorr%c.i16\t%12-15,22R, %E"},
641 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800930, 0xfeb80db0, "vbic%c.i16\t%12-15,22R, %E"},
642 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800c10, 0xfeb80eb0, "vmov%c.i32\t%12-15,22R, %E"},
643 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800c30, 0xfeb80eb0, "vmvn%c.i32\t%12-15,22R, %E"},
644 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800110, 0xfeb809b0, "vorr%c.i32\t%12-15,22R, %E"},
645 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800130, 0xfeb809b0, "vbic%c.i32\t%12-15,22R, %E"},
646 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800010, 0xfeb808b0, "vmov%c.i32\t%12-15,22R, %E"},
647 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800030, 0xfeb808b0, "vmvn%c.i32\t%12-15,22R, %E"},
648 4b0f1a8b pbrook
649 4b0f1a8b pbrook
  /* Two registers and a shift amount */
650 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880810, 0xffb80fd0, "vshrn%c.i16\t%12-15,22D, %0-3,5Q, #%16-18e"},
651 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880850, 0xffb80fd0, "vrshrn%c.i16\t%12-15,22D, %0-3,5Q, #%16-18e"},
652 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880810, 0xfeb80fd0, "vqshrun%c.s16\t%12-15,22D, %0-3,5Q, #%16-18e"},
653 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880850, 0xfeb80fd0, "vqrshrun%c.s16\t%12-15,22D, %0-3,5Q, #%16-18e"},
654 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880910, 0xfeb80fd0, "vqshrn%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-18e"},
655 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880950, 0xfeb80fd0, "vqrshrn%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-18e"},
656 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880a10, 0xfeb80fd0, "vshll%c.%24?us8\t%12-15,22D, %0-3,5Q, #%16-18d"},
657 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900810, 0xffb00fd0, "vshrn%c.i32\t%12-15,22D, %0-3,5Q, #%16-19e"},
658 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900850, 0xffb00fd0, "vrshrn%c.i32\t%12-15,22D, %0-3,5Q, #%16-19e"},
659 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880510, 0xffb80f90, "vshl%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18d"},
660 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3880410, 0xffb80f90, "vsri%c.8\t%12-15,22R, %0-3,5R, #%16-18e"},
661 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3880510, 0xffb80f90, "vsli%c.8\t%12-15,22R, %0-3,5R, #%16-18d"},
662 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3880610, 0xffb80f90, "vqshlu%c.s8\t%12-15,22R, %0-3,5R, #%16-18d"},
663 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900810, 0xfeb00fd0, "vqshrun%c.s32\t%12-15,22D, %0-3,5Q, #%16-19e"},
664 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900850, 0xfeb00fd0, "vqrshrun%c.s32\t%12-15,22D, %0-3,5Q, #%16-19e"},
665 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900910, 0xfeb00fd0, "vqshrn%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-19e"},
666 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900950, 0xfeb00fd0, "vqrshrn%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-19e"},
667 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900a10, 0xfeb00fd0, "vshll%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-19d"},
668 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880010, 0xfeb80f90, "vshr%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
669 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880110, 0xfeb80f90, "vsra%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
670 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880210, 0xfeb80f90, "vrshr%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
671 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880310, 0xfeb80f90, "vrsra%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
672 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2880710, 0xfeb80f90, "vqshl%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18d"},
673 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00810, 0xffa00fd0, "vshrn%c.i64\t%12-15,22D, %0-3,5Q, #%16-20e"},
674 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00850, 0xffa00fd0, "vrshrn%c.i64\t%12-15,22D, %0-3,5Q, #%16-20e"},
675 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900510, 0xffb00f90, "vshl%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19d"},
676 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3900410, 0xffb00f90, "vsri%c.16\t%12-15,22R, %0-3,5R, #%16-19e"},
677 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3900510, 0xffb00f90, "vsli%c.16\t%12-15,22R, %0-3,5R, #%16-19d"},
678 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3900610, 0xffb00f90, "vqshlu%c.s16\t%12-15,22R, %0-3,5R, #%16-19d"},
679 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00a10, 0xfea00fd0, "vshll%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-20d"},
680 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900010, 0xfeb00f90, "vshr%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
681 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900110, 0xfeb00f90, "vsra%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
682 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900210, 0xfeb00f90, "vrshr%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
683 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900310, 0xfeb00f90, "vrsra%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
684 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2900710, 0xfeb00f90, "vqshl%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19d"},
685 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800810, 0xfec00fd0, "vqshrun%c.s64\t%12-15,22D, %0-3,5Q, #%16-20e"},
686 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800850, 0xfec00fd0, "vqrshrun%c.s64\t%12-15,22D, %0-3,5Q, #%16-20e"},
687 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800910, 0xfec00fd0, "vqshrn%c.%24?us64\t%12-15,22D, %0-3,5Q, #%16-20e"},
688 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800950, 0xfec00fd0, "vqrshrn%c.%24?us64\t%12-15,22D, %0-3,5Q, #%16-20e"},
689 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00510, 0xffa00f90, "vshl%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20d"},
690 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3a00410, 0xffa00f90, "vsri%c.32\t%12-15,22R, %0-3,5R, #%16-20e"},
691 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3a00510, 0xffa00f90, "vsli%c.32\t%12-15,22R, %0-3,5R, #%16-20d"},
692 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3a00610, 0xffa00f90, "vqshlu%c.s32\t%12-15,22R, %0-3,5R, #%16-20d"},
693 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00010, 0xfea00f90, "vshr%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
694 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00110, 0xfea00f90, "vsra%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
695 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00210, 0xfea00f90, "vrshr%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
696 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00310, 0xfea00f90, "vrsra%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
697 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00710, 0xfea00f90, "vqshl%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20d"},
698 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800590, 0xff800f90, "vshl%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21d"},
699 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800490, 0xff800f90, "vsri%c.64\t%12-15,22R, %0-3,5R, #%16-21e"},
700 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800590, 0xff800f90, "vsli%c.64\t%12-15,22R, %0-3,5R, #%16-21d"},
701 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800690, 0xff800f90, "vqshlu%c.s64\t%12-15,22R, %0-3,5R, #%16-21d"},
702 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800090, 0xfe800f90, "vshr%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
703 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800190, 0xfe800f90, "vsra%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
704 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800290, 0xfe800f90, "vrshr%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
705 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800390, 0xfe800f90, "vrsra%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
706 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800790, 0xfe800f90, "vqshl%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21d"},
707 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2a00e10, 0xfea00e90, "vcvt%c.%24,8?usff32.%24,8?ffus32\t%12-15,22R, %0-3,5R, #%16-20e"},
708 4b0f1a8b pbrook
709 4b0f1a8b pbrook
  /* Three registers of different lengths */
710 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800e00, 0xfea00f50, "vmull%c.p%20S0\t%12-15,22Q, %16-19,7D, %0-3,5D"},
711 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800400, 0xff800f50, "vaddhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
712 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800600, 0xff800f50, "vsubhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
713 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800900, 0xff800f50, "vqdmlal%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
714 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800b00, 0xff800f50, "vqdmlsl%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
715 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800d00, 0xff800f50, "vqdmull%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
716 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800400, 0xff800f50, "vraddhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
717 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800600, 0xff800f50, "vrsubhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
718 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800000, 0xfe800f50, "vaddl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
719 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800100, 0xfe800f50, "vaddw%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7Q, %0-3,5D"},
720 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800200, 0xfe800f50, "vsubl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
721 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800300, 0xfe800f50, "vsubw%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7Q, %0-3,5D"},
722 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800500, 0xfe800f50, "vabal%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
723 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800700, 0xfe800f50, "vabdl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
724 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800800, 0xfe800f50, "vmlal%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
725 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800a00, 0xfe800f50, "vmlsl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
726 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800c00, 0xfe800f50, "vmull%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
727 4b0f1a8b pbrook
728 4b0f1a8b pbrook
  /* Two registers and a scalar */
729 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800040, 0xff800f50, "vmla%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
730 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800140, 0xff800f50, "vmla%c.f%20-21Sa\t%12-15,22D, %16-19,7D, %D"},
731 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800340, 0xff800f50, "vqdmlal%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
732 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800440, 0xff800f50, "vmls%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
733 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800540, 0xff800f50, "vmls%c.f%20-21S6\t%12-15,22D, %16-19,7D, %D"},
734 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800740, 0xff800f50, "vqdmlsl%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
735 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800840, 0xff800f50, "vmul%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
736 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800940, 0xff800f50, "vmul%c.f%20-21Sa\t%12-15,22D, %16-19,7D, %D"},
737 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800b40, 0xff800f50, "vqdmull%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
738 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800c40, 0xff800f50, "vqdmulh%c.s%20-21S6\t%12-15,22D, %16-19,7D, %D"},
739 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800d40, 0xff800f50, "vqrdmulh%c.s%20-21S6\t%12-15,22D, %16-19,7D, %D"},
740 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800040, 0xff800f50, "vmla%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
741 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800140, 0xff800f50, "vmla%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
742 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800440, 0xff800f50, "vmls%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
743 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800540, 0xff800f50, "vmls%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
744 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800840, 0xff800f50, "vmul%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
745 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800940, 0xff800f50, "vmul%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
746 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800c40, 0xff800f50, "vqdmulh%c.s%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
747 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf3800d40, 0xff800f50, "vqrdmulh%c.s%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
748 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800240, 0xfe800f50, "vmlal%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
749 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800640, 0xfe800f50, "vmlsl%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
750 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf2800a40, 0xfe800f50, "vmull%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
751 4b0f1a8b pbrook
752 4b0f1a8b pbrook
  /* Element and structure load/store */
753 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4a00fc0, 0xffb00fc0, "vld4%c.32\t%C"},
754 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4a00c00, 0xffb00f00, "vld1%c.%6-7S2\t%C"},
755 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4a00d00, 0xffb00f00, "vld2%c.%6-7S2\t%C"},
756 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4a00e00, 0xffb00f00, "vld3%c.%6-7S2\t%C"},
757 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4a00f00, 0xffb00f00, "vld4%c.%6-7S2\t%C"},
758 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000200, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
759 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000300, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
760 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000400, 0xff900f00, "v%21?ls%21?dt3%c.%6-7S2\t%A"},
761 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000500, 0xff900f00, "v%21?ls%21?dt3%c.%6-7S2\t%A"},
762 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000600, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
763 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000700, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
764 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000800, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
765 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000900, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
766 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000a00, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
767 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4000000, 0xff900e00, "v%21?ls%21?dt4%c.%6-7S2\t%A"},
768 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4800000, 0xff900300, "v%21?ls%21?dt1%c.%10-11S2\t%B"},
769 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4800100, 0xff900300, "v%21?ls%21?dt2%c.%10-11S2\t%B"},
770 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4800200, 0xff900300, "v%21?ls%21?dt3%c.%10-11S2\t%B"},
771 4b0f1a8b pbrook
  {FPU_NEON_EXT_V1, 0xf4800300, 0xff900300, "v%21?ls%21?dt4%c.%10-11S2\t%B"},
772 4b0f1a8b pbrook
773 4b0f1a8b pbrook
  {0,0 ,0, 0}
774 4b0f1a8b pbrook
};
775 4b0f1a8b pbrook
776 4b0f1a8b pbrook
/* Opcode tables: ARM, 16-bit Thumb, 32-bit Thumb.  All three are partially
777 4b0f1a8b pbrook
   ordered: they must be searched linearly from the top to obtain a correct
778 4b0f1a8b pbrook
   match.  */
779 4b0f1a8b pbrook
780 4b0f1a8b pbrook
/* print_insn_arm recognizes the following format control codes:
781 4b0f1a8b pbrook

782 4b0f1a8b pbrook
   %%                        %
783 4b0f1a8b pbrook

784 aa0aa4fa bellard
   %a                        print address for ldr/str instruction
785 aa0aa4fa bellard
   %s                   print address for ldr/str halfword/signextend instruction
786 aa0aa4fa bellard
   %b                        print branch destination
787 4b0f1a8b pbrook
   %c                        print condition code (always bits 28-31)
788 aa0aa4fa bellard
   %m                        print register mask for ldm/stm instruction
789 4b0f1a8b pbrook
   %o                        print operand2 (immediate or register + shift)
790 4b0f1a8b pbrook
   %p                        print 'p' iff bits 12-15 are 15
791 4b0f1a8b pbrook
   %t                        print 't' iff bit 21 set and bit 24 clear
792 4b0f1a8b pbrook
   %B                        print arm BLX(1) destination
793 aa0aa4fa bellard
   %C                        print the PSR sub type.
794 4b0f1a8b pbrook
   %U                        print barrier type.
795 4b0f1a8b pbrook
   %P                        print address for pli instruction.
796 4b0f1a8b pbrook

797 4b0f1a8b pbrook
   %<bitfield>r                print as an ARM register
798 4b0f1a8b pbrook
   %<bitfield>d                print the bitfield in decimal
799 4b0f1a8b pbrook
   %<bitfield>W         print the bitfield plus one in decimal
800 4b0f1a8b pbrook
   %<bitfield>x                print the bitfield in hex
801 4b0f1a8b pbrook
   %<bitfield>X                print the bitfield as 1 hex digit without leading "0x"
802 4b0f1a8b pbrook

803 4b0f1a8b pbrook
   %<bitfield>'c        print specified char iff bitfield is all ones
804 4b0f1a8b pbrook
   %<bitfield>`c        print specified char iff bitfield is all zeroes
805 4b0f1a8b pbrook
   %<bitfield>?ab...    select from array of values in big endian order
806 4b0f1a8b pbrook

807 4b0f1a8b pbrook
   %e                   print arm SMI operand (bits 0..7,8..19).
808 4b0f1a8b pbrook
   %E                        print the LSB and WIDTH fields of a BFI or BFC instruction.
809 4b0f1a8b pbrook
   %V                   print the 16-bit immediate field of a MOVT or MOVW instruction.  */
810 4b0f1a8b pbrook
811 4b0f1a8b pbrook
static const struct opcode32 arm_opcodes[] =
812 4b0f1a8b pbrook
{
813 4b0f1a8b pbrook
  /* ARM instructions.  */
814 4b0f1a8b pbrook
  {ARM_EXT_V1, 0xe1a00000, 0xffffffff, "nop\t\t\t(mov r0,r0)"},
815 4b0f1a8b pbrook
  {ARM_EXT_V4T | ARM_EXT_V5, 0x012FFF10, 0x0ffffff0, "bx%c\t%0-3r"},
816 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x00000090, 0x0fe000f0, "mul%20's%c\t%16-19r, %0-3r, %8-11r"},
817 4b0f1a8b pbrook
  {ARM_EXT_V2, 0x00200090, 0x0fe000f0, "mla%20's%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
818 4b0f1a8b pbrook
  {ARM_EXT_V2S, 0x01000090, 0x0fb00ff0, "swp%22'b%c\t%12-15r, %0-3r, [%16-19r]"},
819 4b0f1a8b pbrook
  {ARM_EXT_V3M, 0x00800090, 0x0fa000f0, "%22?sumull%20's%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
820 4b0f1a8b pbrook
  {ARM_EXT_V3M, 0x00a00090, 0x0fa000f0, "%22?sumlal%20's%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
821 4b0f1a8b pbrook
822 4b0f1a8b pbrook
  /* V7 instructions.  */
823 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf450f000, 0xfd70f000, "pli\t%P"},
824 4b0f1a8b pbrook
  {ARM_EXT_V7, 0x0320f0f0, 0x0ffffff0, "dbg%c\t#%0-3d"},
825 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf57ff050, 0xfffffff0, "dmb\t%U"},
826 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf57ff040, 0xfffffff0, "dsb\t%U"},
827 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf57ff060, 0xfffffff0, "isb\t%U"},
828 4b0f1a8b pbrook
829 4b0f1a8b pbrook
  /* ARM V6T2 instructions.  */
830 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x07c0001f, 0x0fe0007f, "bfc%c\t%12-15r, %E"},
831 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x07c00010, 0x0fe00070, "bfi%c\t%12-15r, %0-3r, %E"},
832 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x00600090, 0x0ff000f0, "mls%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
833 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x006000b0, 0x0f7000f0, "strht%c\t%12-15r, %s"},
834 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x00300090, 0x0f300090, "ldr%6's%5?hbt%c\t%12-15r, %s"},
835 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x03000000, 0x0ff00000, "movw%c\t%12-15r, %V"},
836 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x03400000, 0x0ff00000, "movt%c\t%12-15r, %V"},
837 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x06ff0f30, 0x0fff0ff0, "rbit%c\t%12-15r, %0-3r"},
838 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0x07a00050, 0x0fa00070, "%22?usbfx%c\t%12-15r, %0-3r, #%7-11d, #%16-20W"},
839 4b0f1a8b pbrook
840 4b0f1a8b pbrook
  /* ARM V6Z instructions.  */
841 4b0f1a8b pbrook
  {ARM_EXT_V6Z, 0x01600070, 0x0ff000f0, "smc%c\t%e"},
842 4b0f1a8b pbrook
843 4b0f1a8b pbrook
  /* ARM V6K instructions.  */
844 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xf57ff01f, 0xffffffff, "clrex"},
845 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01d00f9f, 0x0ff00fff, "ldrexb%c\t%12-15r, [%16-19r]"},
846 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01b00f9f, 0x0ff00fff, "ldrexd%c\t%12-15r, [%16-19r]"},
847 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01f00f9f, 0x0ff00fff, "ldrexh%c\t%12-15r, [%16-19r]"},
848 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01c00f90, 0x0ff00ff0, "strexb%c\t%12-15r, %0-3r, [%16-19r]"},
849 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01a00f90, 0x0ff00ff0, "strexd%c\t%12-15r, %0-3r, [%16-19r]"},
850 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x01e00f90, 0x0ff00ff0, "strexh%c\t%12-15r, %0-3r, [%16-19r]"},
851 4b0f1a8b pbrook
852 4b0f1a8b pbrook
  /* ARM V6K NOP hints.  */
853 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x0320f001, 0x0fffffff, "yield%c"},
854 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x0320f002, 0x0fffffff, "wfe%c"},
855 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x0320f003, 0x0fffffff, "wfi%c"},
856 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x0320f004, 0x0fffffff, "sev%c"},
857 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0x0320f000, 0x0fffff00, "nop%c\t{%0-7d}"},
858 4b0f1a8b pbrook
859 4b0f1a8b pbrook
  /* ARM V6 instructions. */
860 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf1080000, 0xfffffe3f, "cpsie\t%8'a%7'i%6'f"},
861 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf10a0000, 0xfffffe20, "cpsie\t%8'a%7'i%6'f,#%0-4d"},
862 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf10C0000, 0xfffffe3f, "cpsid\t%8'a%7'i%6'f"},
863 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf10e0000, 0xfffffe20, "cpsid\t%8'a%7'i%6'f,#%0-4d"},
864 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf1000000, 0xfff1fe20, "cps\t#%0-4d"},
865 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800010, 0x0ff00ff0, "pkhbt%c\t%12-15r, %16-19r, %0-3r"},
866 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800010, 0x0ff00070, "pkhbt%c\t%12-15r, %16-19r, %0-3r, lsl #%7-11d"},
867 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800050, 0x0ff00ff0, "pkhtb%c\t%12-15r, %16-19r, %0-3r, asr #32"},
868 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800050, 0x0ff00070, "pkhtb%c\t%12-15r, %16-19r, %0-3r, asr #%7-11d"},
869 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x01900f9f, 0x0ff00fff, "ldrex%c\tr%12-15d, [%16-19r]"},
870 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200f10, 0x0ff00ff0, "qadd16%c\t%12-15r, %16-19r, %0-3r"},
871 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200f90, 0x0ff00ff0, "qadd8%c\t%12-15r, %16-19r, %0-3r"},
872 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200f30, 0x0ff00ff0, "qaddsubx%c\t%12-15r, %16-19r, %0-3r"},
873 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200f70, 0x0ff00ff0, "qsub16%c\t%12-15r, %16-19r, %0-3r"},
874 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200ff0, 0x0ff00ff0, "qsub8%c\t%12-15r, %16-19r, %0-3r"},
875 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06200f50, 0x0ff00ff0, "qsubaddx%c\t%12-15r, %16-19r, %0-3r"},
876 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100f10, 0x0ff00ff0, "sadd16%c\t%12-15r, %16-19r, %0-3r"},
877 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100f90, 0x0ff00ff0, "sadd8%c\t%12-15r, %16-19r, %0-3r"},
878 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100f30, 0x0ff00ff0, "saddaddx%c\t%12-15r, %16-19r, %0-3r"},
879 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300f10, 0x0ff00ff0, "shadd16%c\t%12-15r, %16-19r, %0-3r"},
880 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300f90, 0x0ff00ff0, "shadd8%c\t%12-15r, %16-19r, %0-3r"},
881 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300f30, 0x0ff00ff0, "shaddsubx%c\t%12-15r, %16-19r, %0-3r"},
882 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300f70, 0x0ff00ff0, "shsub16%c\t%12-15r, %16-19r, %0-3r"},
883 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300ff0, 0x0ff00ff0, "shsub8%c\t%12-15r, %16-19r, %0-3r"},
884 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06300f50, 0x0ff00ff0, "shsubaddx%c\t%12-15r, %16-19r, %0-3r"},
885 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100f70, 0x0ff00ff0, "ssub16%c\t%12-15r, %16-19r, %0-3r"},
886 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100ff0, 0x0ff00ff0, "ssub8%c\t%12-15r, %16-19r, %0-3r"},
887 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06100f50, 0x0ff00ff0, "ssubaddx%c\t%12-15r, %16-19r, %0-3r"},
888 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500f10, 0x0ff00ff0, "uadd16%c\t%12-15r, %16-19r, %0-3r"},
889 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500f90, 0x0ff00ff0, "uadd8%c\t%12-15r, %16-19r, %0-3r"},
890 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500f30, 0x0ff00ff0, "uaddsubx%c\t%12-15r, %16-19r, %0-3r"},
891 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700f10, 0x0ff00ff0, "uhadd16%c\t%12-15r, %16-19r, %0-3r"},
892 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700f90, 0x0ff00ff0, "uhadd8%c\t%12-15r, %16-19r, %0-3r"},
893 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700f30, 0x0ff00ff0, "uhaddsubx%c\t%12-15r, %16-19r, %0-3r"},
894 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700f70, 0x0ff00ff0, "uhsub16%c\t%12-15r, %16-19r, %0-3r"},
895 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700ff0, 0x0ff00ff0, "uhsub8%c\t%12-15r, %16-19r, %0-3r"},
896 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06700f50, 0x0ff00ff0, "uhsubaddx%c\t%12-15r, %16-19r, %0-3r"},
897 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600f10, 0x0ff00ff0, "uqadd16%c\t%12-15r, %16-19r, %0-3r"},
898 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600f90, 0x0ff00ff0, "uqadd8%c\t%12-15r, %16-19r, %0-3r"},
899 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600f30, 0x0ff00ff0, "uqaddsubx%c\t%12-15r, %16-19r, %0-3r"},
900 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600f70, 0x0ff00ff0, "uqsub16%c\t%12-15r, %16-19r, %0-3r"},
901 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600ff0, 0x0ff00ff0, "uqsub8%c\t%12-15r, %16-19r, %0-3r"},
902 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06600f50, 0x0ff00ff0, "uqsubaddx%c\t%12-15r, %16-19r, %0-3r"},
903 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500f70, 0x0ff00ff0, "usub16%c\t%12-15r, %16-19r, %0-3r"},
904 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500ff0, 0x0ff00ff0, "usub8%c\t%12-15r, %16-19r, %0-3r"},
905 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06500f50, 0x0ff00ff0, "usubaddx%c\t%12-15r, %16-19r, %0-3r"},
906 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0f30, 0x0fff0ff0, "rev%c\t\%12-15r, %0-3r"},
907 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0fb0, 0x0fff0ff0, "rev16%c\t\%12-15r, %0-3r"},
908 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ff0fb0, 0x0fff0ff0, "revsh%c\t\%12-15r, %0-3r"},
909 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf8100a00, 0xfe50ffff, "rfe%23?id%24?ba\t\%16-19r%21'!"},
910 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0070, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r"},
911 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0470, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #8"},
912 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0870, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #16"},
913 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06bf0c70, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #24"},
914 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x068f0070, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r"},
915 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x068f0470, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #8"},
916 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x068f0870, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #16"},
917 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x068f0c70, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #24"},
918 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06af0070, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r"},
919 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06af0470, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #8"},
920 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06af0870, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #16"},
921 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06af0c70, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #24"},
922 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ff0070, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r"},
923 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ff0470, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #8"},
924 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ff0870, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #16"},
925 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ff0c70, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #24"},
926 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06cf0070, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r"},
927 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06cf0470, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #8"},
928 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06cf0870, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #16"},
929 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06cf0c70, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #24"},
930 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ef0070, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r"},
931 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ef0470, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #8"},
932 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ef0870, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #16"},
933 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06ef0c70, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #24"},
934 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06b00070, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r"},
935 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06b00470, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #8"},
936 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06b00870, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #16"},
937 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06b00c70, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #24"},
938 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800070, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r"},
939 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800470, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #8"},
940 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800870, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #16"},
941 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800c70, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #24"},
942 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00070, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r"},
943 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00470, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #8"},
944 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00870, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #16"},
945 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00c70, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #24"},
946 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06f00070, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r"},
947 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06f00470, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #8"},
948 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06f00870, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #16"},
949 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06f00c70, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #24"},
950 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06c00070, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r"},
951 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06c00470, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ror #8"},
952 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06c00870, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ror #16"},
953 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06c00c70, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
954 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00070, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r"},
955 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00470, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #8"},
956 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00870, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #16"},
957 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00c70, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #24"},
958 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06800fb0, 0x0ff00ff0, "sel%c\t%12-15r, %16-19r, %0-3r"},
959 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf1010000, 0xfffffc00, "setend\t%9?ble"},
960 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x0700f010, 0x0ff0f0d0, "smuad%5'x%c\t%16-19r, %0-3r, %8-11r"},
961 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x0700f050, 0x0ff0f0d0, "smusd%5'x%c\t%16-19r, %0-3r, %8-11r"},
962 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07000010, 0x0ff000d0, "smlad%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
963 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07400010, 0x0ff000d0, "smlald%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
964 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07000050, 0x0ff000d0, "smlsd%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
965 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07400050, 0x0ff000d0, "smlsld%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
966 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x0750f010, 0x0ff0f0d0, "smmul%5'r%c\t%16-19r, %0-3r, %8-11r"},
967 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07500010, 0x0ff000d0, "smmla%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
968 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x075000d0, 0x0ff000d0, "smmls%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
969 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xf84d0500, 0xfe5fffe0, "srs%23?id%24?ba\t%16-19r%21'!, #%0-4d"},
970 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00010, 0x0fe00ff0, "ssat%c\t%12-15r, #%16-20W, %0-3r"},
971 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00010, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, lsl #%7-11d"},
972 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00050, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, asr #%7-11d"},
973 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06a00f30, 0x0ff00ff0, "ssat16%c\t%12-15r, #%16-19W, %0-3r"},
974 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x01800f90, 0x0ff00ff0, "strex%c\t%12-15r, %0-3r, [%16-19r]"},
975 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x00400090, 0x0ff000f0, "umaal%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
976 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x0780f010, 0x0ff0f0f0, "usad8%c\t%16-19r, %0-3r, %8-11r"},
977 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x07800010, 0x0ff000f0, "usada8%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
978 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00010, 0x0fe00ff0, "usat%c\t%12-15r, #%16-20d, %0-3r"},
979 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00010, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, lsl #%7-11d"},
980 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00050, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, asr #%7-11d"},
981 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x06e00f30, 0x0ff00ff0, "usat16%c\t%12-15r, #%16-19d, %0-3r"},
982 4b0f1a8b pbrook
983 4b0f1a8b pbrook
  /* V5J instruction.  */
984 4b0f1a8b pbrook
  {ARM_EXT_V5J, 0x012fff20, 0x0ffffff0, "bxj%c\t%0-3r"},
985 4b0f1a8b pbrook
986 4b0f1a8b pbrook
  /* V5 Instructions.  */
987 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xe1200070, 0xfff000f0, "bkpt\t0x%16-19X%12-15X%8-11X%0-3X"},
988 4b0f1a8b pbrook
  {ARM_EXT_V5, 0xfa000000, 0xfe000000, "blx\t%B"},
989 4b0f1a8b pbrook
  {ARM_EXT_V5, 0x012fff30, 0x0ffffff0, "blx%c\t%0-3r"},
990 4b0f1a8b pbrook
  {ARM_EXT_V5, 0x016f0f10, 0x0fff0ff0, "clz%c\t%12-15r, %0-3r"},
991 4b0f1a8b pbrook
992 4b0f1a8b pbrook
  /* V5E "El Segundo" Instructions.  */
993 4b0f1a8b pbrook
  {ARM_EXT_V5E, 0x000000d0, 0x0e1000f0, "ldrd%c\t%12-15r, %s"},
994 4b0f1a8b pbrook
  {ARM_EXT_V5E, 0x000000f0, 0x0e1000f0, "strd%c\t%12-15r, %s"},
995 4b0f1a8b pbrook
  {ARM_EXT_V5E, 0xf450f000, 0xfc70f000, "pld\t%a"},
996 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01000080, 0x0ff000f0, "smlabb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
997 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x010000a0, 0x0ff000f0, "smlatb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
998 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x010000c0, 0x0ff000f0, "smlabt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
999 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x010000e0, 0x0ff000f0, "smlatt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
1000 4b0f1a8b pbrook
1001 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01200080, 0x0ff000f0, "smlawb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
1002 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x012000c0, 0x0ff000f0, "smlawt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
1003 4b0f1a8b pbrook
1004 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01400080, 0x0ff000f0, "smlalbb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
1005 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x014000a0, 0x0ff000f0, "smlaltb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
1006 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x014000c0, 0x0ff000f0, "smlalbt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
1007 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x014000e0, 0x0ff000f0, "smlaltt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
1008 4b0f1a8b pbrook
1009 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01600080, 0x0ff0f0f0, "smulbb%c\t%16-19r, %0-3r, %8-11r"},
1010 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x016000a0, 0x0ff0f0f0, "smultb%c\t%16-19r, %0-3r, %8-11r"},
1011 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x016000c0, 0x0ff0f0f0, "smulbt%c\t%16-19r, %0-3r, %8-11r"},
1012 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x016000e0, 0x0ff0f0f0, "smultt%c\t%16-19r, %0-3r, %8-11r"},
1013 4b0f1a8b pbrook
1014 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x012000a0, 0x0ff0f0f0, "smulwb%c\t%16-19r, %0-3r, %8-11r"},
1015 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x012000e0, 0x0ff0f0f0, "smulwt%c\t%16-19r, %0-3r, %8-11r"},
1016 4b0f1a8b pbrook
1017 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01000050, 0x0ff00ff0,  "qadd%c\t%12-15r, %0-3r, %16-19r"},
1018 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01400050, 0x0ff00ff0, "qdadd%c\t%12-15r, %0-3r, %16-19r"},
1019 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01200050, 0x0ff00ff0,  "qsub%c\t%12-15r, %0-3r, %16-19r"},
1020 4b0f1a8b pbrook
  {ARM_EXT_V5ExP, 0x01600050, 0x0ff00ff0, "qdsub%c\t%12-15r, %0-3r, %16-19r"},
1021 4b0f1a8b pbrook
1022 4b0f1a8b pbrook
  /* ARM Instructions.  */
1023 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00000090, 0x0e100090, "str%6's%5?hb%c\t%12-15r, %s"},
1024 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00100090, 0x0e100090, "ldr%6's%5?hb%c\t%12-15r, %s"},
1025 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00000000, 0x0de00000, "and%20's%c\t%12-15r, %16-19r, %o"},
1026 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00200000, 0x0de00000, "eor%20's%c\t%12-15r, %16-19r, %o"},
1027 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00400000, 0x0de00000, "sub%20's%c\t%12-15r, %16-19r, %o"},
1028 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00600000, 0x0de00000, "rsb%20's%c\t%12-15r, %16-19r, %o"},
1029 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00800000, 0x0de00000, "add%20's%c\t%12-15r, %16-19r, %o"},
1030 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00a00000, 0x0de00000, "adc%20's%c\t%12-15r, %16-19r, %o"},
1031 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00c00000, 0x0de00000, "sbc%20's%c\t%12-15r, %16-19r, %o"},
1032 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00e00000, 0x0de00000, "rsc%20's%c\t%12-15r, %16-19r, %o"},
1033 4b0f1a8b pbrook
  {ARM_EXT_V3, 0x0120f000, 0x0db0f000, "msr%c\t%22?SCPSR%C, %o"},
1034 4b0f1a8b pbrook
  {ARM_EXT_V3, 0x010f0000, 0x0fbf0fff, "mrs%c\t%12-15r, %22?SCPSR"},
1035 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01000000, 0x0de00000, "tst%p%c\t%16-19r, %o"},
1036 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01200000, 0x0de00000, "teq%p%c\t%16-19r, %o"},
1037 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01400000, 0x0de00000, "cmp%p%c\t%16-19r, %o"},
1038 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01600000, 0x0de00000, "cmn%p%c\t%16-19r, %o"},
1039 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01800000, 0x0de00000, "orr%20's%c\t%12-15r, %16-19r, %o"},
1040 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x03a00000, 0x0fef0000, "mov%20's%c\t%12-15r, %o"},
1041 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00000, 0x0def0ff0, "mov%20's%c\t%12-15r, %0-3r"},
1042 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00000, 0x0def0060, "lsl%20's%c\t%12-15r, %q"},
1043 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00020, 0x0def0060, "lsr%20's%c\t%12-15r, %q"},
1044 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00040, 0x0def0060, "asr%20's%c\t%12-15r, %q"},
1045 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00060, 0x0def0ff0, "rrx%20's%c\t%12-15r, %0-3r"},
1046 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01a00060, 0x0def0060, "ror%20's%c\t%12-15r, %q"},
1047 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01c00000, 0x0de00000, "bic%20's%c\t%12-15r, %16-19r, %o"},
1048 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x01e00000, 0x0de00000, "mvn%20's%c\t%12-15r, %o"},
1049 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x052d0004, 0x0fff0fff, "push%c\t{%12-15r}\t\t; (str%c %12-15r, %a)"},
1050 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x04000000, 0x0e100000, "str%22'b%t%c\t%12-15r, %a"},
1051 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x06000000, 0x0e100ff0, "str%22'b%t%c\t%12-15r, %a"},
1052 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x04000000, 0x0c100010, "str%22'b%t%c\t%12-15r, %a"},
1053 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x06000010, 0x0e000010, "undefined"},
1054 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x049d0004, 0x0fff0fff, "pop%c\t{%12-15r}\t\t; (ldr%c %12-15r, %a)"},
1055 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x04100000, 0x0c100000, "ldr%22'b%t%c\t%12-15r, %a"},
1056 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x092d0000, 0x0fff0000, "push%c\t%m"},
1057 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x08800000, 0x0ff00000, "stm%c\t%16-19r%21'!, %m%22'^"},
1058 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x08000000, 0x0e100000, "stm%23?id%24?ba%c\t%16-19r%21'!, %m%22'^"},
1059 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x08bd0000, 0x0fff0000, "pop%c\t%m"},
1060 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x08900000, 0x0f900000, "ldm%c\t%16-19r%21'!, %m%22'^"},
1061 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x08100000, 0x0e100000, "ldm%23?id%24?ba%c\t%16-19r%21'!, %m%22'^"},
1062 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x0a000000, 0x0e000000, "b%24'l%c\t%b"},
1063 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x0f000000, 0x0f000000, "svc%c\t%0-23x"},
1064 4b0f1a8b pbrook
1065 4b0f1a8b pbrook
  /* The rest.  */
1066 4b0f1a8b pbrook
  {ARM_EXT_V1, 0x00000000, 0x00000000, "undefined instruction %0-31x"},
1067 4b0f1a8b pbrook
  {0, 0x00000000, 0x00000000, 0}
1068 4b0f1a8b pbrook
};
1069 4b0f1a8b pbrook
1070 4b0f1a8b pbrook
/* print_insn_thumb16 recognizes the following format control codes:
1071 4b0f1a8b pbrook

1072 aa0aa4fa bellard
   %S                   print Thumb register (bits 3..5 as high number if bit 6 set)
1073 4b0f1a8b pbrook
   %D                   print Thumb register (bits 0..2 as high number if bit 7 set)
1074 aa0aa4fa bellard
   %<bitfield>I         print bitfield as a signed decimal
1075 aa0aa4fa bellard
                                   (top bit of range being the sign bit)
1076 aa0aa4fa bellard
   %N                   print Thumb register mask (with LR)
1077 aa0aa4fa bellard
   %O                   print Thumb register mask (with PC)
1078 4b0f1a8b pbrook
   %M                   print Thumb register mask
1079 4b0f1a8b pbrook
   %b                        print CZB's 6-bit unsigned branch destination
1080 4b0f1a8b pbrook
   %s                        print Thumb right-shift immediate (6..10; 0 == 32).
1081 4b0f1a8b pbrook
   %c                        print the condition code
1082 4b0f1a8b pbrook
   %C                        print the condition code, or "s" if not conditional
1083 4b0f1a8b pbrook
   %x                        print warning if conditional an not at end of IT block"
1084 4b0f1a8b pbrook
   %X                        print "\t; unpredictable <IT:code>" if conditional
1085 4b0f1a8b pbrook
   %I                        print IT instruction suffix and operands
1086 4b0f1a8b pbrook
   %<bitfield>r                print bitfield as an ARM register
1087 4b0f1a8b pbrook
   %<bitfield>d                print bitfield as a decimal
1088 aa0aa4fa bellard
   %<bitfield>H         print (bitfield * 2) as a decimal
1089 4b0f1a8b pbrook
   %<bitfield>W         print (bitfield * 4) as a decimal
1090 aa0aa4fa bellard
   %<bitfield>a         print (bitfield * 4) as a pc-rel offset + decoded symbol
1091 4b0f1a8b pbrook
   %<bitfield>B         print Thumb branch destination (signed displacement)
1092 4b0f1a8b pbrook
   %<bitfield>c         print bitfield as a condition code
1093 4b0f1a8b pbrook
   %<bitnum>'c                print specified char iff bit is one
1094 4b0f1a8b pbrook
   %<bitnum>?ab                print a if bit is one else print b.  */
1095 aa0aa4fa bellard
1096 4b0f1a8b pbrook
static const struct opcode16 thumb_opcodes[] =
1097 aa0aa4fa bellard
{
1098 aa0aa4fa bellard
  /* Thumb instructions.  */
1099 aa0aa4fa bellard
1100 4b0f1a8b pbrook
  /* ARM V6K no-argument instructions.  */
1101 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf00, 0xffff, "nop%c"},
1102 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf10, 0xffff, "yield%c"},
1103 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf20, 0xffff, "wfe%c"},
1104 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf30, 0xffff, "wfi%c"},
1105 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf40, 0xffff, "sev%c"},
1106 4b0f1a8b pbrook
  {ARM_EXT_V6K, 0xbf00, 0xff0f, "nop%c\t{%4-7d}"},
1107 4b0f1a8b pbrook
1108 4b0f1a8b pbrook
  /* ARM V6T2 instructions.  */
1109 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xb900, 0xfd00, "cbnz\t%0-2r, %b%X"},
1110 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xb100, 0xfd00, "cbz\t%0-2r, %b%X"},
1111 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xbf00, 0xff00, "it%I%X"},
1112 4b0f1a8b pbrook
1113 4b0f1a8b pbrook
  /* ARM V6.  */
1114 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb660, 0xfff8, "cpsie\t%2'a%1'i%0'f%X"},
1115 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb670, 0xfff8, "cpsid\t%2'a%1'i%0'f%X"},
1116 4b0f1a8b pbrook
  {ARM_EXT_V6, 0x4600, 0xffc0, "mov%c\t%0-2r, %3-5r"},
1117 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xba00, 0xffc0, "rev%c\t%0-2r, %3-5r"},
1118 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xba40, 0xffc0, "rev16%c\t%0-2r, %3-5r"},
1119 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xbac0, 0xffc0, "revsh%c\t%0-2r, %3-5r"},
1120 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb650, 0xfff7, "setend\t%3?ble%X"},
1121 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb200, 0xffc0, "sxth%c\t%0-2r, %3-5r"},
1122 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb240, 0xffc0, "sxtb%c\t%0-2r, %3-5r"},
1123 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb280, 0xffc0, "uxth%c\t%0-2r, %3-5r"},
1124 4b0f1a8b pbrook
  {ARM_EXT_V6, 0xb2c0, 0xffc0, "uxtb%c\t%0-2r, %3-5r"},
1125 4b0f1a8b pbrook
1126 aa0aa4fa bellard
  /* ARM V5 ISA extends Thumb.  */
1127 4b0f1a8b pbrook
  {ARM_EXT_V5T, 0xbe00, 0xff00, "bkpt\t%0-7x"}, /* Is always unconditional.  */
1128 4b0f1a8b pbrook
  /* This is BLX(2).  BLX(1) is a 32-bit instruction.  */
1129 4b0f1a8b pbrook
  {ARM_EXT_V5T, 0x4780, 0xff87, "blx%c\t%3-6r%x"},        /* note: 4 bit register number.  */
1130 4b0f1a8b pbrook
  /* ARM V4T ISA (Thumb v1).  */
1131 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x46C0, 0xFFFF, "nop%c\t\t\t(mov r8, r8)"},
1132 aa0aa4fa bellard
  /* Format 4.  */
1133 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4000, 0xFFC0, "and%C\t%0-2r, %3-5r"},
1134 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4040, 0xFFC0, "eor%C\t%0-2r, %3-5r"},
1135 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4080, 0xFFC0, "lsl%C\t%0-2r, %3-5r"},
1136 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x40C0, 0xFFC0, "lsr%C\t%0-2r, %3-5r"},
1137 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4100, 0xFFC0, "asr%C\t%0-2r, %3-5r"},
1138 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4140, 0xFFC0, "adc%C\t%0-2r, %3-5r"},
1139 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4180, 0xFFC0, "sbc%C\t%0-2r, %3-5r"},
1140 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x41C0, 0xFFC0, "ror%C\t%0-2r, %3-5r"},
1141 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4200, 0xFFC0, "tst%c\t%0-2r, %3-5r"},
1142 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4240, 0xFFC0, "neg%C\t%0-2r, %3-5r"},
1143 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4280, 0xFFC0, "cmp%c\t%0-2r, %3-5r"},
1144 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x42C0, 0xFFC0, "cmn%c\t%0-2r, %3-5r"},
1145 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4300, 0xFFC0, "orr%C\t%0-2r, %3-5r"},
1146 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4340, 0xFFC0, "mul%C\t%0-2r, %3-5r"},
1147 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4380, 0xFFC0, "bic%C\t%0-2r, %3-5r"},
1148 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x43C0, 0xFFC0, "mvn%C\t%0-2r, %3-5r"},
1149 aa0aa4fa bellard
  /* format 13 */
1150 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xB000, 0xFF80, "add%c\tsp, #%0-6W"},
1151 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xB080, 0xFF80, "sub%c\tsp, #%0-6W"},
1152 aa0aa4fa bellard
  /* format 5 */
1153 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4700, 0xFF80, "bx%c\t%S%x"},
1154 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4400, 0xFF00, "add%c\t%D, %S"},
1155 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4500, 0xFF00, "cmp%c\t%D, %S"},
1156 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4600, 0xFF00, "mov%c\t%D, %S"},
1157 aa0aa4fa bellard
  /* format 14 */
1158 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xB400, 0xFE00, "push%c\t%N"},
1159 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xBC00, 0xFE00, "pop%c\t%O"},
1160 aa0aa4fa bellard
  /* format 2 */
1161 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x1800, 0xFE00, "add%C\t%0-2r, %3-5r, %6-8r"},
1162 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x1A00, 0xFE00, "sub%C\t%0-2r, %3-5r, %6-8r"},
1163 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x1C00, 0xFE00, "add%C\t%0-2r, %3-5r, #%6-8d"},
1164 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x1E00, 0xFE00, "sub%C\t%0-2r, %3-5r, #%6-8d"},
1165 aa0aa4fa bellard
  /* format 8 */
1166 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x5200, 0xFE00, "strh%c\t%0-2r, [%3-5r, %6-8r]"},
1167 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x5A00, 0xFE00, "ldrh%c\t%0-2r, [%3-5r, %6-8r]"},
1168 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x5600, 0xF600, "ldrs%11?hb%c\t%0-2r, [%3-5r, %6-8r]"},
1169 aa0aa4fa bellard
  /* format 7 */
1170 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x5000, 0xFA00, "str%10'b%c\t%0-2r, [%3-5r, %6-8r]"},
1171 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x5800, 0xFA00, "ldr%10'b%c\t%0-2r, [%3-5r, %6-8r]"},
1172 aa0aa4fa bellard
  /* format 1 */
1173 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x0000, 0xF800, "lsl%C\t%0-2r, %3-5r, #%6-10d"},
1174 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x0800, 0xF800, "lsr%C\t%0-2r, %3-5r, %s"},
1175 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x1000, 0xF800, "asr%C\t%0-2r, %3-5r, %s"},
1176 aa0aa4fa bellard
  /* format 3 */
1177 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x2000, 0xF800, "mov%C\t%8-10r, #%0-7d"},
1178 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x2800, 0xF800, "cmp%c\t%8-10r, #%0-7d"},
1179 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x3000, 0xF800, "add%C\t%8-10r, #%0-7d"},
1180 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x3800, 0xF800, "sub%C\t%8-10r, #%0-7d"},
1181 aa0aa4fa bellard
  /* format 6 */
1182 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x4800, 0xF800, "ldr%c\t%8-10r, [pc, #%0-7W]\t(%0-7a)"},  /* TODO: Disassemble PC relative "LDR rD,=<symbolic>" */
1183 aa0aa4fa bellard
  /* format 9 */
1184 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x6000, 0xF800, "str%c\t%0-2r, [%3-5r, #%6-10W]"},
1185 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x6800, 0xF800, "ldr%c\t%0-2r, [%3-5r, #%6-10W]"},
1186 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x7000, 0xF800, "strb%c\t%0-2r, [%3-5r, #%6-10d]"},
1187 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x7800, 0xF800, "ldrb%c\t%0-2r, [%3-5r, #%6-10d]"},
1188 aa0aa4fa bellard
  /* format 10 */
1189 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x8000, 0xF800, "strh%c\t%0-2r, [%3-5r, #%6-10H]"},
1190 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x8800, 0xF800, "ldrh%c\t%0-2r, [%3-5r, #%6-10H]"},
1191 aa0aa4fa bellard
  /* format 11 */
1192 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x9000, 0xF800, "str%c\t%8-10r, [sp, #%0-7W]"},
1193 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0x9800, 0xF800, "ldr%c\t%8-10r, [sp, #%0-7W]"},
1194 aa0aa4fa bellard
  /* format 12 */
1195 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xA000, 0xF800, "add%c\t%8-10r, pc, #%0-7W\t(adr %8-10r, %0-7a)"},
1196 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xA800, 0xF800, "add%c\t%8-10r, sp, #%0-7W"},
1197 aa0aa4fa bellard
  /* format 15 */
1198 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xC000, 0xF800, "stmia%c\t%8-10r!, %M"},
1199 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xC800, 0xF800, "ldmia%c\t%8-10r!, %M"},
1200 aa0aa4fa bellard
  /* format 17 */
1201 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xDF00, 0xFF00, "svc%c\t%0-7d"},
1202 4b0f1a8b pbrook
  /* format 16 */
1203 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xDE00, 0xFE00, "undefined"},
1204 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xD000, 0xF000, "b%8-11c.n\t%0-7B%X"},
1205 4b0f1a8b pbrook
  /* format 18 */
1206 4b0f1a8b pbrook
  {ARM_EXT_V4T, 0xE000, 0xF800, "b%c.n\t%0-10B%x"},
1207 4b0f1a8b pbrook
1208 4b0f1a8b pbrook
  /* The E800 .. FFFF range is unconditionally redirected to the
1209 4b0f1a8b pbrook
     32-bit table, because even in pre-V6T2 ISAs, BL and BLX(1) pairs
1210 4b0f1a8b pbrook
     are processed via that table.  Thus, we can never encounter a
1211 4b0f1a8b pbrook
     bare "second half of BL/BLX(1)" instruction here.  */
1212 4b0f1a8b pbrook
  {ARM_EXT_V1,  0x0000, 0x0000, "undefined"},
1213 4b0f1a8b pbrook
  {0, 0, 0, 0}
1214 aa0aa4fa bellard
};
1215 aa0aa4fa bellard
1216 4b0f1a8b pbrook
/* Thumb32 opcodes use the same table structure as the ARM opcodes.
1217 4b0f1a8b pbrook
   We adopt the convention that hw1 is the high 16 bits of .value and
1218 4b0f1a8b pbrook
   .mask, hw2 the low 16 bits.
1219 4b0f1a8b pbrook

1220 4b0f1a8b pbrook
   print_insn_thumb32 recognizes the following format control codes:
1221 4b0f1a8b pbrook

1222 4b0f1a8b pbrook
       %%                %
1223 4b0f1a8b pbrook

1224 4b0f1a8b pbrook
       %I                print a 12-bit immediate from hw1[10],hw2[14:12,7:0]
1225 4b0f1a8b pbrook
       %M                print a modified 12-bit immediate (same location)
1226 4b0f1a8b pbrook
       %J                print a 16-bit immediate from hw1[3:0,10],hw2[14:12,7:0]
1227 4b0f1a8b pbrook
       %K                print a 16-bit immediate from hw2[3:0],hw1[3:0],hw2[11:4]
1228 4b0f1a8b pbrook
       %S                print a possibly-shifted Rm
1229 4b0f1a8b pbrook

1230 4b0f1a8b pbrook
       %a                print the address of a plain load/store
1231 4b0f1a8b pbrook
       %w                print the width and signedness of a core load/store
1232 4b0f1a8b pbrook
       %m                print register mask for ldm/stm
1233 4b0f1a8b pbrook

1234 4b0f1a8b pbrook
       %E                print the lsb and width fields of a bfc/bfi instruction
1235 4b0f1a8b pbrook
       %F                print the lsb and width fields of a sbfx/ubfx instruction
1236 4b0f1a8b pbrook
       %b                print a conditional branch offset
1237 4b0f1a8b pbrook
       %B                print an unconditional branch offset
1238 4b0f1a8b pbrook
       %s                print the shift field of an SSAT instruction
1239 4b0f1a8b pbrook
       %R                print the rotation field of an SXT instruction
1240 4b0f1a8b pbrook
       %U                print barrier type.
1241 4b0f1a8b pbrook
       %P                print address for pli instruction.
1242 4b0f1a8b pbrook
       %c                print the condition code
1243 4b0f1a8b pbrook
       %x                print warning if conditional an not at end of IT block"
1244 4b0f1a8b pbrook
       %X                print "\t; unpredictable <IT:code>" if conditional
1245 4b0f1a8b pbrook

1246 4b0f1a8b pbrook
       %<bitfield>d        print bitfield in decimal
1247 4b0f1a8b pbrook
       %<bitfield>W        print bitfield*4 in decimal
1248 4b0f1a8b pbrook
       %<bitfield>r        print bitfield as an ARM register
1249 4b0f1a8b pbrook
       %<bitfield>c        print bitfield as a condition code
1250 4b0f1a8b pbrook

1251 4b0f1a8b pbrook
       %<bitfield>'c        print specified char iff bitfield is all ones
1252 4b0f1a8b pbrook
       %<bitfield>`c        print specified char iff bitfield is all zeroes
1253 4b0f1a8b pbrook
       %<bitfield>?ab... select from array of values in big endian order
1254 4b0f1a8b pbrook

1255 4b0f1a8b pbrook
   With one exception at the bottom (done because BL and BLX(1) need
1256 4b0f1a8b pbrook
   to come dead last), this table was machine-sorted first in
1257 4b0f1a8b pbrook
   decreasing order of number of bits set in the mask, then in
1258 4b0f1a8b pbrook
   increasing numeric order of mask, then in increasing numeric order
1259 4b0f1a8b pbrook
   of opcode.  This order is not the clearest for a human reader, but
1260 4b0f1a8b pbrook
   is guaranteed never to catch a special-case bit pattern with a more
1261 4b0f1a8b pbrook
   general mask, which is important, because this instruction encoding
1262 4b0f1a8b pbrook
   makes heavy use of special-case bit patterns.  */
1263 4b0f1a8b pbrook
static const struct opcode32 thumb32_opcodes[] =
1264 4b0f1a8b pbrook
{
1265 4b0f1a8b pbrook
  /* V7 instructions.  */
1266 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf910f000, 0xff70f000, "pli%c\t%a"},
1267 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf3af80f0, 0xfffffff0, "dbg%c\t#%0-3d"},
1268 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf3bf8f50, 0xfffffff0, "dmb%c\t%U"},
1269 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf3bf8f40, 0xfffffff0, "dsb%c\t%U"},
1270 4b0f1a8b pbrook
  {ARM_EXT_V7, 0xf3bf8f60, 0xfffffff0, "isb%c\t%U"},
1271 4b0f1a8b pbrook
  {ARM_EXT_DIV, 0xfb90f0f0, 0xfff0f0f0, "sdiv%c\t%8-11r, %16-19r, %0-3r"},
1272 4b0f1a8b pbrook
  {ARM_EXT_DIV, 0xfbb0f0f0, 0xfff0f0f0, "udiv%c\t%8-11r, %16-19r, %0-3r"},
1273 4b0f1a8b pbrook
1274 4b0f1a8b pbrook
  /* Instructions defined in the basic V6T2 set.  */
1275 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8000, 0xffffffff, "nop%c.w"},
1276 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8001, 0xffffffff, "yield%c.w"},
1277 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8002, 0xffffffff, "wfe%c.w"},
1278 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8003, 0xffffffff, "wfi%c.w"},
1279 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af9004, 0xffffffff, "sev%c.w"},
1280 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8000, 0xffffff00, "nop%c.w\t{%0-7d}"},
1281 4b0f1a8b pbrook
1282 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3bf8f2f, 0xffffffff, "clrex%c"},
1283 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8400, 0xffffff1f, "cpsie.w\t%7'a%6'i%5'f%X"},
1284 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8600, 0xffffff1f, "cpsid.w\t%7'a%6'i%5'f%X"},
1285 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3c08f00, 0xfff0ffff, "bxj%c\t%16-19r%x"},
1286 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe810c000, 0xffd0ffff, "rfedb%c\t%16-19r%21'!"},
1287 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe990c000, 0xffd0ffff, "rfeia%c\t%16-19r%21'!"},
1288 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3ef8000, 0xffeff000, "mrs%c\t%8-11r, %D"},
1289 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8100, 0xffffffe0, "cps\t#%0-4d%X"},
1290 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8d0f000, 0xfff0fff0, "tbb%c\t[%16-19r, %0-3r]%x"},
1291 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8d0f010, 0xfff0fff0, "tbh%c\t[%16-19r, %0-3r, lsl #1]%x"},
1292 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8500, 0xffffff00, "cpsie\t%7'a%6'i%5'f, #%0-4d%X"},
1293 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3af8700, 0xffffff00, "cpsid\t%7'a%6'i%5'f, #%0-4d%X"},
1294 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3de8f00, 0xffffff00, "subs%c\tpc, lr, #%0-7d"},
1295 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3808000, 0xffe0f000, "msr%c\t%C, %16-19r"},
1296 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8500f00, 0xfff00fff, "ldrex%c\t%12-15r, [%16-19r]"},
1297 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8d00f4f, 0xfff00fef, "ldrex%4?hb%c\t%12-15r, [%16-19r]"},
1298 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe800c000, 0xffd0ffe0, "srsdb%c\t%16-19r%21'!, #%0-4d"},
1299 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe980c000, 0xffd0ffe0, "srsia%c\t%16-19r%21'!, #%0-4d"},
1300 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa0ff080, 0xfffff0c0, "sxth%c.w\t%8-11r, %0-3r%R"},
1301 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa1ff080, 0xfffff0c0, "uxth%c.w\t%8-11r, %0-3r%R"},
1302 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa2ff080, 0xfffff0c0, "sxtb16%c\t%8-11r, %0-3r%R"},
1303 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa3ff080, 0xfffff0c0, "uxtb16%c\t%8-11r, %0-3r%R"},
1304 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa4ff080, 0xfffff0c0, "sxtb%c.w\t%8-11r, %0-3r%R"},
1305 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa5ff080, 0xfffff0c0, "uxtb%c.w\t%8-11r, %0-3r%R"},
1306 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8400000, 0xfff000ff, "strex%c\t%8-11r, %12-15r, [%16-19r]"},
1307 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8d0007f, 0xfff000ff, "ldrexd%c\t%12-15r, %8-11r, [%16-19r]"},
1308 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f000, 0xfff0f0f0, "sadd8%c\t%8-11r, %16-19r, %0-3r"},
1309 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f010, 0xfff0f0f0, "qadd8%c\t%8-11r, %16-19r, %0-3r"},
1310 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f020, 0xfff0f0f0, "shadd8%c\t%8-11r, %16-19r, %0-3r"},
1311 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f040, 0xfff0f0f0, "uadd8%c\t%8-11r, %16-19r, %0-3r"},
1312 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f050, 0xfff0f0f0, "uqadd8%c\t%8-11r, %16-19r, %0-3r"},
1313 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f060, 0xfff0f0f0, "uhadd8%c\t%8-11r, %16-19r, %0-3r"},
1314 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f080, 0xfff0f0f0, "qadd%c\t%8-11r, %0-3r, %16-19r"},
1315 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f090, 0xfff0f0f0, "qdadd%c\t%8-11r, %0-3r, %16-19r"},
1316 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f0a0, 0xfff0f0f0, "qsub%c\t%8-11r, %0-3r, %16-19r"},
1317 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa80f0b0, 0xfff0f0f0, "qdsub%c\t%8-11r, %0-3r, %16-19r"},
1318 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f000, 0xfff0f0f0, "sadd16%c\t%8-11r, %16-19r, %0-3r"},
1319 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f010, 0xfff0f0f0, "qadd16%c\t%8-11r, %16-19r, %0-3r"},
1320 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f020, 0xfff0f0f0, "shadd16%c\t%8-11r, %16-19r, %0-3r"},
1321 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f040, 0xfff0f0f0, "uadd16%c\t%8-11r, %16-19r, %0-3r"},
1322 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f050, 0xfff0f0f0, "uqadd16%c\t%8-11r, %16-19r, %0-3r"},
1323 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f060, 0xfff0f0f0, "uhadd16%c\t%8-11r, %16-19r, %0-3r"},
1324 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f080, 0xfff0f0f0, "rev%c.w\t%8-11r, %16-19r"},
1325 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f090, 0xfff0f0f0, "rev16%c.w\t%8-11r, %16-19r"},
1326 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f0a0, 0xfff0f0f0, "rbit%c\t%8-11r, %16-19r"},
1327 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa90f0b0, 0xfff0f0f0, "revsh%c.w\t%8-11r, %16-19r"},
1328 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f000, 0xfff0f0f0, "saddsubx%c\t%8-11r, %16-19r, %0-3r"},
1329 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f010, 0xfff0f0f0, "qaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1330 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f020, 0xfff0f0f0, "shaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1331 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f040, 0xfff0f0f0, "uaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1332 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f050, 0xfff0f0f0, "uqaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1333 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f060, 0xfff0f0f0, "uhaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1334 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfaa0f080, 0xfff0f0f0, "sel%c\t%8-11r, %16-19r, %0-3r"},
1335 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfab0f080, 0xfff0f0f0, "clz%c\t%8-11r, %16-19r"},
1336 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f000, 0xfff0f0f0, "ssub8%c\t%8-11r, %16-19r, %0-3r"},
1337 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f010, 0xfff0f0f0, "qsub8%c\t%8-11r, %16-19r, %0-3r"},
1338 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f020, 0xfff0f0f0, "shsub8%c\t%8-11r, %16-19r, %0-3r"},
1339 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f040, 0xfff0f0f0, "usub8%c\t%8-11r, %16-19r, %0-3r"},
1340 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f050, 0xfff0f0f0, "uqsub8%c\t%8-11r, %16-19r, %0-3r"},
1341 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfac0f060, 0xfff0f0f0, "uhsub8%c\t%8-11r, %16-19r, %0-3r"},
1342 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f000, 0xfff0f0f0, "ssub16%c\t%8-11r, %16-19r, %0-3r"},
1343 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f010, 0xfff0f0f0, "qsub16%c\t%8-11r, %16-19r, %0-3r"},
1344 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f020, 0xfff0f0f0, "shsub16%c\t%8-11r, %16-19r, %0-3r"},
1345 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f040, 0xfff0f0f0, "usub16%c\t%8-11r, %16-19r, %0-3r"},
1346 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f050, 0xfff0f0f0, "uqsub16%c\t%8-11r, %16-19r, %0-3r"},
1347 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfad0f060, 0xfff0f0f0, "uhsub16%c\t%8-11r, %16-19r, %0-3r"},
1348 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f000, 0xfff0f0f0, "ssubaddx%c\t%8-11r, %16-19r, %0-3r"},
1349 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f010, 0xfff0f0f0, "qsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1350 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f020, 0xfff0f0f0, "shsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1351 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f040, 0xfff0f0f0, "usubaddx%c\t%8-11r, %16-19r, %0-3r"},
1352 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f050, 0xfff0f0f0, "uqsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1353 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfae0f060, 0xfff0f0f0, "uhsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1354 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb00f000, 0xfff0f0f0, "mul%c.w\t%8-11r, %16-19r, %0-3r"},
1355 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb70f000, 0xfff0f0f0, "usad8%c\t%8-11r, %16-19r, %0-3r"},
1356 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa00f000, 0xffe0f0f0, "lsl%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1357 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa20f000, 0xffe0f0f0, "lsr%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1358 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa40f000, 0xffe0f0f0, "asr%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1359 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa60f000, 0xffe0f0f0, "ror%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1360 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8c00f40, 0xfff00fe0, "strex%4?hb%c\t%0-3r, %12-15r, [%16-19r]"},
1361 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3200000, 0xfff0f0e0, "ssat16%c\t%8-11r, #%0-4d, %16-19r"},
1362 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3a00000, 0xfff0f0e0, "usat16%c\t%8-11r, #%0-4d, %16-19r"},
1363 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb20f000, 0xfff0f0e0, "smuad%4'x%c\t%8-11r, %16-19r, %0-3r"},
1364 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb30f000, 0xfff0f0e0, "smulw%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1365 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb40f000, 0xfff0f0e0, "smusd%4'x%c\t%8-11r, %16-19r, %0-3r"},
1366 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb50f000, 0xfff0f0e0, "smmul%4'r%c\t%8-11r, %16-19r, %0-3r"},
1367 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa00f080, 0xfff0f0c0, "sxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1368 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa10f080, 0xfff0f0c0, "uxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1369 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa20f080, 0xfff0f0c0, "sxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1370 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa30f080, 0xfff0f0c0, "uxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1371 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa40f080, 0xfff0f0c0, "sxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1372 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfa50f080, 0xfff0f0c0, "uxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1373 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb10f000, 0xfff0f0c0, "smul%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1374 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf36f0000, 0xffff8020, "bfc%c\t%8-11r, %E"},
1375 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea100f00, 0xfff08f00, "tst%c.w\t%16-19r, %S"},
1376 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea900f00, 0xfff08f00, "teq%c\t%16-19r, %S"},
1377 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeb100f00, 0xfff08f00, "cmn%c.w\t%16-19r, %S"},
1378 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xebb00f00, 0xfff08f00, "cmp%c.w\t%16-19r, %S"},
1379 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0100f00, 0xfbf08f00, "tst%c.w\t%16-19r, %M"},
1380 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0900f00, 0xfbf08f00, "teq%c\t%16-19r, %M"},
1381 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1100f00, 0xfbf08f00, "cmn%c.w\t%16-19r, %M"},
1382 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1b00f00, 0xfbf08f00, "cmp%c.w\t%16-19r, %M"},
1383 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea4f0000, 0xffef8000, "mov%20's%c.w\t%8-11r, %S"},
1384 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea6f0000, 0xffef8000, "mvn%20's%c.w\t%8-11r, %S"},
1385 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8c00070, 0xfff000f0, "strexd%c\t%0-3r, %12-15r, %8-11r, [%16-19r]"},
1386 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb000000, 0xfff000f0, "mla%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1387 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb000010, 0xfff000f0, "mls%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1388 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb700000, 0xfff000f0, "usada8%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1389 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb800000, 0xfff000f0, "smull%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1390 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfba00000, 0xfff000f0, "umull%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1391 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbc00000, 0xfff000f0, "smlal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1392 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbe00000, 0xfff000f0, "umlal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1393 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbe00060, 0xfff000f0, "umaal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1394 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8500f00, 0xfff00f00, "ldrex%c\t%12-15r, [%16-19r, #%0-7W]"},
1395 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf7f08000, 0xfff0f000, "smc%c\t%K"},
1396 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf04f0000, 0xfbef8000, "mov%20's%c.w\t%8-11r, %M"},
1397 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf06f0000, 0xfbef8000, "mvn%20's%c.w\t%8-11r, %M"},
1398 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf810f000, 0xff70f000, "pld%c\t%a"},
1399 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb200000, 0xfff000e0, "smlad%4'x%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1400 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb300000, 0xfff000e0, "smlaw%4?tb%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1401 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb400000, 0xfff000e0, "smlsd%4'x%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1402 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb500000, 0xfff000e0, "smmla%4'r%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1403 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb600000, 0xfff000e0, "smmls%4'r%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1404 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbc000c0, 0xfff000e0, "smlald%4'x%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1405 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbd000c0, 0xfff000e0, "smlsld%4'x%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1406 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeac00000, 0xfff08030, "pkhbt%c\t%8-11r, %16-19r, %S"},
1407 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeac00020, 0xfff08030, "pkhtb%c\t%8-11r, %16-19r, %S"},
1408 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3400000, 0xfff08020, "sbfx%c\t%8-11r, %16-19r, %F"},
1409 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3c00000, 0xfff08020, "ubfx%c\t%8-11r, %16-19r, %F"},
1410 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf8000e00, 0xff900f00, "str%wt%c\t%12-15r, %a"},
1411 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfb100000, 0xfff000c0, "smla%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1412 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xfbc00080, 0xfff000c0, "smlal%5?tb%4?tb%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1413 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3600000, 0xfff08020, "bfi%c\t%8-11r, %16-19r, %E"},
1414 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf8100e00, 0xfe900f00, "ldr%wt%c\t%12-15r, %a"},
1415 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3000000, 0xffd08020, "ssat%c\t%8-11r, #%0-4d, %16-19r%s"},
1416 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3800000, 0xffd08020, "usat%c\t%8-11r, #%0-4d, %16-19r%s"},
1417 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf2000000, 0xfbf08000, "addw%c\t%8-11r, %16-19r, %I"},
1418 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf2400000, 0xfbf08000, "movw%c\t%8-11r, %J"},
1419 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf2a00000, 0xfbf08000, "subw%c\t%8-11r, %16-19r, %I"},
1420 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf2c00000, 0xfbf08000, "movt%c\t%8-11r, %J"},
1421 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea000000, 0xffe08000, "and%20's%c.w\t%8-11r, %16-19r, %S"},
1422 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea200000, 0xffe08000, "bic%20's%c.w\t%8-11r, %16-19r, %S"},
1423 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea400000, 0xffe08000, "orr%20's%c.w\t%8-11r, %16-19r, %S"},
1424 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea600000, 0xffe08000, "orn%20's%c\t%8-11r, %16-19r, %S"},
1425 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xea800000, 0xffe08000, "eor%20's%c.w\t%8-11r, %16-19r, %S"},
1426 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeb000000, 0xffe08000, "add%20's%c.w\t%8-11r, %16-19r, %S"},
1427 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeb400000, 0xffe08000, "adc%20's%c.w\t%8-11r, %16-19r, %S"},
1428 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeb600000, 0xffe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %S"},
1429 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xeba00000, 0xffe08000, "sub%20's%c.w\t%8-11r, %16-19r, %S"},
1430 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xebc00000, 0xffe08000, "rsb%20's%c\t%8-11r, %16-19r, %S"},
1431 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8400000, 0xfff00000, "strex%c\t%8-11r, %12-15r, [%16-19r, #%0-7W]"},
1432 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0000000, 0xfbe08000, "and%20's%c.w\t%8-11r, %16-19r, %M"},
1433 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0200000, 0xfbe08000, "bic%20's%c.w\t%8-11r, %16-19r, %M"},
1434 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0400000, 0xfbe08000, "orr%20's%c.w\t%8-11r, %16-19r, %M"},
1435 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0600000, 0xfbe08000, "orn%20's%c\t%8-11r, %16-19r, %M"},
1436 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0800000, 0xfbe08000, "eor%20's%c.w\t%8-11r, %16-19r, %M"},
1437 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1000000, 0xfbe08000, "add%20's%c.w\t%8-11r, %16-19r, %M"},
1438 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1400000, 0xfbe08000, "adc%20's%c.w\t%8-11r, %16-19r, %M"},
1439 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1600000, 0xfbe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %M"},
1440 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1a00000, 0xfbe08000, "sub%20's%c.w\t%8-11r, %16-19r, %M"},
1441 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf1c00000, 0xfbe08000, "rsb%20's%c\t%8-11r, %16-19r, %M"},
1442 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8800000, 0xffd00000, "stmia%c.w\t%16-19r%21'!, %m"},
1443 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8900000, 0xffd00000, "ldmia%c.w\t%16-19r%21'!, %m"},
1444 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9000000, 0xffd00000, "stmdb%c\t%16-19r%21'!, %m"},
1445 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9100000, 0xffd00000, "ldmdb%c\t%16-19r%21'!, %m"},
1446 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9c00000, 0xffd000ff, "strd%c\t%12-15r, %8-11r, [%16-19r]"},
1447 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9d00000, 0xffd000ff, "ldrd%c\t%12-15r, %8-11r, [%16-19r]"},
1448 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9400000, 0xff500000, "strd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1449 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe9500000, 0xff500000, "ldrd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1450 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8600000, 0xff700000, "strd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1451 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xe8700000, 0xff700000, "ldrd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1452 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf8000000, 0xff100000, "str%w%c.w\t%12-15r, %a"},
1453 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf8100000, 0xfe100000, "ldr%w%c.w\t%12-15r, %a"},
1454 4b0f1a8b pbrook
1455 4b0f1a8b pbrook
  /* Filter out Bcc with cond=E or F, which are used for other instructions.  */
1456 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3c08000, 0xfbc0d000, "undefined (bcc, cond=0xF)"},
1457 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf3808000, 0xfbc0d000, "undefined (bcc, cond=0xE)"},
1458 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0008000, 0xf800d000, "b%22-25c.w\t%b%X"},
1459 4b0f1a8b pbrook
  {ARM_EXT_V6T2, 0xf0009000, 0xf800d000, "b%c.w\t%B%x"},
1460 4b0f1a8b pbrook
1461 4b0f1a8b pbrook
  /* These have been 32-bit since the invention of Thumb.  */
1462 4b0f1a8b pbrook
  {ARM_EXT_V4T,  0xf000c000, 0xf800d000, "blx%c\t%B%x"},
1463 4b0f1a8b pbrook
  {ARM_EXT_V4T,  0xf000d000, 0xf800d000, "bl%c\t%B%x"},
1464 4b0f1a8b pbrook
1465 4b0f1a8b pbrook
  /* Fallback.  */
1466 4b0f1a8b pbrook
  {ARM_EXT_V1,   0x00000000, 0x00000000, "undefined"},
1467 4b0f1a8b pbrook
  {0, 0, 0, 0}
1468 4b0f1a8b pbrook
};
1469 aa0aa4fa bellard
1470 4b0f1a8b pbrook
static const char *const arm_conditional[] =
1471 4b0f1a8b pbrook
{"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
1472 4b0f1a8b pbrook
 "hi", "ls", "ge", "lt", "gt", "le", "al", "<und>", ""};
1473 aa0aa4fa bellard
1474 4b0f1a8b pbrook
static const char *const arm_fp_const[] =
1475 4b0f1a8b pbrook
{"0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0"};
1476 aa0aa4fa bellard
1477 4b0f1a8b pbrook
static const char *const arm_shift[] =
1478 4b0f1a8b pbrook
{"lsl", "lsr", "asr", "ror"};
1479 aa0aa4fa bellard
1480 aa0aa4fa bellard
typedef struct
1481 aa0aa4fa bellard
{
1482 4b0f1a8b pbrook
  const char *name;
1483 4b0f1a8b pbrook
  const char *description;
1484 4b0f1a8b pbrook
  const char *reg_names[16];
1485 aa0aa4fa bellard
}
1486 aa0aa4fa bellard
arm_regname;
1487 aa0aa4fa bellard
1488 4b0f1a8b pbrook
static const arm_regname regnames[] =
1489 aa0aa4fa bellard
{
1490 aa0aa4fa bellard
  { "raw" , "Select raw register names",
1491 aa0aa4fa bellard
    { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"}},
1492 aa0aa4fa bellard
  { "gcc",  "Select register names used by GCC",
1493 aa0aa4fa bellard
    { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1494 aa0aa4fa bellard
  { "std",  "Select register names used in ARM's ISA documentation",
1495 aa0aa4fa bellard
    { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "sp",  "lr",  "pc" }},
1496 aa0aa4fa bellard
  { "apcs", "Select register names used in the APCS",
1497 aa0aa4fa bellard
    { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1498 aa0aa4fa bellard
  { "atpcs", "Select register names used in the ATPCS",
1499 aa0aa4fa bellard
    { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "v7",  "v8",  "IP",  "SP",  "LR",  "PC" }},
1500 aa0aa4fa bellard
  { "special-atpcs", "Select special register names used in the ATPCS",
1501 4b0f1a8b pbrook
    { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "WR", "v5", "SB", "SL",  "FP",  "IP",  "SP",  "LR",  "PC" }},
1502 4b0f1a8b pbrook
};
1503 4b0f1a8b pbrook
1504 4b0f1a8b pbrook
static const char *const iwmmxt_wwnames[] =
1505 4b0f1a8b pbrook
{"b", "h", "w", "d"};
1506 4b0f1a8b pbrook
1507 4b0f1a8b pbrook
static const char *const iwmmxt_wwssnames[] =
1508 4b0f1a8b pbrook
{"b", "bus", "bc", "bss",
1509 4b0f1a8b pbrook
 "h", "hus", "hc", "hss",
1510 4b0f1a8b pbrook
 "w", "wus", "wc", "wss",
1511 4b0f1a8b pbrook
 "d", "dus", "dc", "dss"
1512 aa0aa4fa bellard
};
1513 aa0aa4fa bellard
1514 4b0f1a8b pbrook
static const char *const iwmmxt_regnames[] =
1515 4b0f1a8b pbrook
{ "wr0", "wr1", "wr2", "wr3", "wr4", "wr5", "wr6", "wr7",
1516 4b0f1a8b pbrook
  "wr8", "wr9", "wr10", "wr11", "wr12", "wr13", "wr14", "wr15"
1517 4b0f1a8b pbrook
};
1518 4b0f1a8b pbrook
1519 4b0f1a8b pbrook
static const char *const iwmmxt_cregnames[] =
1520 4b0f1a8b pbrook
{ "wcid", "wcon", "wcssf", "wcasf", "reserved", "reserved", "reserved", "reserved",
1521 4b0f1a8b pbrook
  "wcgr0", "wcgr1", "wcgr2", "wcgr3", "reserved", "reserved", "reserved", "reserved"
1522 4b0f1a8b pbrook
};
1523 4b0f1a8b pbrook
1524 4b0f1a8b pbrook
/* Default to GCC register name set.  */
1525 4b0f1a8b pbrook
static unsigned int regname_selected = 1;
1526 aa0aa4fa bellard
1527 aa0aa4fa bellard
#define NUM_ARM_REGNAMES  NUM_ELEM (regnames)
1528 aa0aa4fa bellard
#define arm_regnames      regnames[regname_selected].reg_names
1529 aa0aa4fa bellard
1530 47cbc7aa Juan Quintela
static bfd_boolean force_thumb = false;
1531 4b0f1a8b pbrook
1532 4b0f1a8b pbrook
/* Current IT instruction state.  This contains the same state as the IT
1533 4b0f1a8b pbrook
   bits in the CPSR.  */
1534 4b0f1a8b pbrook
static unsigned int ifthen_state;
1535 4b0f1a8b pbrook
/* IT state for the next instruction.  */
1536 4b0f1a8b pbrook
static unsigned int ifthen_next_state;
1537 4b0f1a8b pbrook
/* The address of the insn for which the IT state is valid.  */
1538 4b0f1a8b pbrook
static bfd_vma ifthen_address;
1539 4b0f1a8b pbrook
#define IFTHEN_COND ((ifthen_state >> 4) & 0xf)
1540 4b0f1a8b pbrook
1541 4b0f1a8b pbrook
/* Cached mapping symbol state.  */
1542 4b0f1a8b pbrook
enum map_type {
1543 4b0f1a8b pbrook
  MAP_ARM,
1544 4b0f1a8b pbrook
  MAP_THUMB,
1545 4b0f1a8b pbrook
  MAP_DATA
1546 4b0f1a8b pbrook
};
1547 aa0aa4fa bellard
1548 4b0f1a8b pbrook
enum map_type last_type;
1549 4b0f1a8b pbrook
int last_mapping_sym = -1;
1550 4b0f1a8b pbrook
bfd_vma last_mapping_addr = 0;
1551 aa0aa4fa bellard
1552 4b0f1a8b pbrook
/* Decode a bitfield of the form matching regexp (N(-N)?,)*N(-N)?.
1553 4b0f1a8b pbrook
   Returns pointer to following character of the format string and
1554 4b0f1a8b pbrook
   fills in *VALUEP and *WIDTHP with the extracted value and number of
1555 4b0f1a8b pbrook
   bits extracted.  WIDTHP can be NULL. */
1556 4b0f1a8b pbrook
1557 4b0f1a8b pbrook
static const char *
1558 4b0f1a8b pbrook
arm_decode_bitfield (const char *ptr, unsigned long insn,
1559 4b0f1a8b pbrook
                     unsigned long *valuep, int *widthp)
1560 4b0f1a8b pbrook
{
1561 4b0f1a8b pbrook
  unsigned long value = 0;
1562 4b0f1a8b pbrook
  int width = 0;
1563 4b0f1a8b pbrook
1564 4b0f1a8b pbrook
  do
1565 4b0f1a8b pbrook
    {
1566 4b0f1a8b pbrook
      int start, end;
1567 4b0f1a8b pbrook
      int bits;
1568 4b0f1a8b pbrook
1569 4b0f1a8b pbrook
      for (start = 0; *ptr >= '0' && *ptr <= '9'; ptr++)
1570 4b0f1a8b pbrook
        start = start * 10 + *ptr - '0';
1571 4b0f1a8b pbrook
      if (*ptr == '-')
1572 4b0f1a8b pbrook
        for (end = 0, ptr++; *ptr >= '0' && *ptr <= '9'; ptr++)
1573 4b0f1a8b pbrook
          end = end * 10 + *ptr - '0';
1574 4b0f1a8b pbrook
      else
1575 4b0f1a8b pbrook
        end = start;
1576 4b0f1a8b pbrook
      bits = end - start;
1577 4b0f1a8b pbrook
      if (bits < 0)
1578 4b0f1a8b pbrook
        abort ();
1579 4b0f1a8b pbrook
      value |= ((insn >> start) & ((2ul << bits) - 1)) << width;
1580 4b0f1a8b pbrook
      width += bits + 1;
1581 4b0f1a8b pbrook
    }
1582 4b0f1a8b pbrook
  while (*ptr++ == ',');
1583 4b0f1a8b pbrook
  *valuep = value;
1584 4b0f1a8b pbrook
  if (widthp)
1585 4b0f1a8b pbrook
    *widthp = width;
1586 4b0f1a8b pbrook
  return ptr - 1;
1587 4b0f1a8b pbrook
}
1588 4b0f1a8b pbrook
1589 aa0aa4fa bellard
static void
1590 6e2d864e Stefan Weil
arm_decode_shift (long given, fprintf_function func, void *stream,
1591 4b0f1a8b pbrook
                  int print_shift)
1592 aa0aa4fa bellard
{
1593 aa0aa4fa bellard
  func (stream, "%s", arm_regnames[given & 0xf]);
1594 3b46e624 ths
1595 aa0aa4fa bellard
  if ((given & 0xff0) != 0)
1596 aa0aa4fa bellard
    {
1597 aa0aa4fa bellard
      if ((given & 0x10) == 0)
1598 aa0aa4fa bellard
        {
1599 aa0aa4fa bellard
          int amount = (given & 0xf80) >> 7;
1600 aa0aa4fa bellard
          int shift = (given & 0x60) >> 5;
1601 3b46e624 ths
1602 aa0aa4fa bellard
          if (amount == 0)
1603 aa0aa4fa bellard
            {
1604 aa0aa4fa bellard
              if (shift == 3)
1605 aa0aa4fa bellard
                {
1606 aa0aa4fa bellard
                  func (stream, ", rrx");
1607 aa0aa4fa bellard
                  return;
1608 aa0aa4fa bellard
                }
1609 3b46e624 ths
1610 aa0aa4fa bellard
              amount = 32;
1611 aa0aa4fa bellard
            }
1612 3b46e624 ths
1613 4b0f1a8b pbrook
          if (print_shift)
1614 4b0f1a8b pbrook
            func (stream, ", %s #%d", arm_shift[shift], amount);
1615 4b0f1a8b pbrook
          else
1616 4b0f1a8b pbrook
            func (stream, ", #%d", amount);
1617 aa0aa4fa bellard
        }
1618 4b0f1a8b pbrook
      else if (print_shift)
1619 aa0aa4fa bellard
        func (stream, ", %s %s", arm_shift[(given & 0x60) >> 5],
1620 aa0aa4fa bellard
              arm_regnames[(given & 0xf00) >> 8]);
1621 4b0f1a8b pbrook
      else
1622 4b0f1a8b pbrook
        func (stream, ", %s", arm_regnames[(given & 0xf00) >> 8]);
1623 aa0aa4fa bellard
    }
1624 aa0aa4fa bellard
}
1625 aa0aa4fa bellard
1626 4b0f1a8b pbrook
/* Print one coprocessor instruction on INFO->STREAM.
1627 47cbc7aa Juan Quintela
   Return true if the instuction matched, false if this is not a
1628 4b0f1a8b pbrook
   recognised coprocessor instruction.  */
1629 aa0aa4fa bellard
1630 4b0f1a8b pbrook
static bfd_boolean
1631 4b0f1a8b pbrook
print_insn_coprocessor (bfd_vma pc, struct disassemble_info *info, long given,
1632 4b0f1a8b pbrook
                        bfd_boolean thumb)
1633 aa0aa4fa bellard
{
1634 4b0f1a8b pbrook
  const struct opcode32 *insn;
1635 4b0f1a8b pbrook
  void *stream = info->stream;
1636 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
1637 4b0f1a8b pbrook
  unsigned long mask;
1638 4b0f1a8b pbrook
  unsigned long value;
1639 4b0f1a8b pbrook
  int cond;
1640 4b0f1a8b pbrook
1641 4b0f1a8b pbrook
  for (insn = coprocessor_opcodes; insn->assembler; insn++)
1642 aa0aa4fa bellard
    {
1643 4b0f1a8b pbrook
      if (insn->value == FIRST_IWMMXT_INSN
1644 4b0f1a8b pbrook
          && info->mach != bfd_mach_arm_XScale
1645 4b0f1a8b pbrook
          && info->mach != bfd_mach_arm_iWMMXt
1646 4b0f1a8b pbrook
          && info->mach != bfd_mach_arm_iWMMXt2)
1647 4b0f1a8b pbrook
        insn = insn + IWMMXT_INSN_COUNT;
1648 4b0f1a8b pbrook
1649 4b0f1a8b pbrook
      mask = insn->mask;
1650 4b0f1a8b pbrook
      value = insn->value;
1651 4b0f1a8b pbrook
      if (thumb)
1652 4b0f1a8b pbrook
        {
1653 4b0f1a8b pbrook
          /* The high 4 bits are 0xe for Arm conditional instructions, and
1654 4b0f1a8b pbrook
             0xe for arm unconditional instructions.  The rest of the
1655 4b0f1a8b pbrook
             encoding is the same.  */
1656 4b0f1a8b pbrook
          mask |= 0xf0000000;
1657 4b0f1a8b pbrook
          value |= 0xe0000000;
1658 4b0f1a8b pbrook
          if (ifthen_state)
1659 4b0f1a8b pbrook
            cond = IFTHEN_COND;
1660 4b0f1a8b pbrook
          else
1661 4b0f1a8b pbrook
            cond = 16;
1662 4b0f1a8b pbrook
        }
1663 4b0f1a8b pbrook
      else
1664 4b0f1a8b pbrook
        {
1665 4b0f1a8b pbrook
          /* Only match unconditional instuctions against unconditional
1666 4b0f1a8b pbrook
             patterns.  */
1667 4b0f1a8b pbrook
          if ((given & 0xf0000000) == 0xf0000000)
1668 4b0f1a8b pbrook
            {
1669 4b0f1a8b pbrook
              mask |= 0xf0000000;
1670 4b0f1a8b pbrook
              cond = 16;
1671 4b0f1a8b pbrook
            }
1672 4b0f1a8b pbrook
          else
1673 4b0f1a8b pbrook
            {
1674 4b0f1a8b pbrook
              cond = (given >> 28) & 0xf;
1675 4b0f1a8b pbrook
              if (cond == 0xe)
1676 4b0f1a8b pbrook
                cond = 16;
1677 4b0f1a8b pbrook
            }
1678 4b0f1a8b pbrook
        }
1679 4b0f1a8b pbrook
      if ((given & mask) == value)
1680 aa0aa4fa bellard
        {
1681 4b0f1a8b pbrook
          const char *c;
1682 3b46e624 ths
1683 aa0aa4fa bellard
          for (c = insn->assembler; *c; c++)
1684 aa0aa4fa bellard
            {
1685 aa0aa4fa bellard
              if (*c == '%')
1686 aa0aa4fa bellard
                {
1687 aa0aa4fa bellard
                  switch (*++c)
1688 aa0aa4fa bellard
                    {
1689 aa0aa4fa bellard
                    case '%':
1690 aa0aa4fa bellard
                      func (stream, "%%");
1691 aa0aa4fa bellard
                      break;
1692 aa0aa4fa bellard
1693 4b0f1a8b pbrook
                    case 'A':
1694 4b0f1a8b pbrook
                      func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
1695 aa0aa4fa bellard
1696 4b0f1a8b pbrook
                      if ((given & (1 << 24)) != 0)
1697 4b0f1a8b pbrook
                        {
1698 4b0f1a8b pbrook
                          int offset = given & 0xff;
1699 aa0aa4fa bellard
1700 4b0f1a8b pbrook
                          if (offset)
1701 4b0f1a8b pbrook
                            func (stream, ", #%s%d]%s",
1702 4b0f1a8b pbrook
                                  ((given & 0x00800000) == 0 ? "-" : ""),
1703 4b0f1a8b pbrook
                                  offset * 4,
1704 4b0f1a8b pbrook
                                  ((given & 0x00200000) != 0 ? "!" : ""));
1705 aa0aa4fa bellard
                          else
1706 4b0f1a8b pbrook
                            func (stream, "]");
1707 aa0aa4fa bellard
                        }
1708 aa0aa4fa bellard
                      else
1709 aa0aa4fa bellard
                        {
1710 4b0f1a8b pbrook
                          int offset = given & 0xff;
1711 aa0aa4fa bellard
1712 4b0f1a8b pbrook
                          func (stream, "]");
1713 4b0f1a8b pbrook
1714 4b0f1a8b pbrook
                          if (given & (1 << 21))
1715 aa0aa4fa bellard
                            {
1716 4b0f1a8b pbrook
                              if (offset)
1717 4b0f1a8b pbrook
                                func (stream, ", #%s%d",
1718 4b0f1a8b pbrook
                                      ((given & 0x00800000) == 0 ? "-" : ""),
1719 4b0f1a8b pbrook
                                      offset * 4);
1720 aa0aa4fa bellard
                            }
1721 4b0f1a8b pbrook
                          else
1722 4b0f1a8b pbrook
                            func (stream, ", {%d}", offset);
1723 aa0aa4fa bellard
                        }
1724 aa0aa4fa bellard
                      break;
1725 aa0aa4fa bellard
1726 4b0f1a8b pbrook
                    case 'B':
1727 4b0f1a8b pbrook
                      {
1728 4b0f1a8b pbrook
                        int regno = ((given >> 12) & 0xf) | ((given >> (22 - 4)) & 0x10);
1729 4b0f1a8b pbrook
                        int offset = (given >> 1) & 0x3f;
1730 4b0f1a8b pbrook
1731 4b0f1a8b pbrook
                        if (offset == 1)
1732 4b0f1a8b pbrook
                          func (stream, "{d%d}", regno);
1733 4b0f1a8b pbrook
                        else if (regno + offset > 32)
1734 4b0f1a8b pbrook
                          func (stream, "{d%d-<overflow reg d%d>}", regno, regno + offset - 1);
1735 4b0f1a8b pbrook
                        else
1736 4b0f1a8b pbrook
                          func (stream, "{d%d-d%d}", regno, regno + offset - 1);
1737 4b0f1a8b pbrook
                      }
1738 4b0f1a8b pbrook
                      break;
1739 3b46e624 ths
1740 4b0f1a8b pbrook
                    case 'C':
1741 4b0f1a8b pbrook
                      {
1742 4b0f1a8b pbrook
                        int rn = (given >> 16) & 0xf;
1743 4b0f1a8b pbrook
                        int offset = (given & 0xff) * 4;
1744 4b0f1a8b pbrook
                        int add = (given >> 23) & 1;
1745 3b46e624 ths
1746 4b0f1a8b pbrook
                        func (stream, "[%s", arm_regnames[rn]);
1747 3b46e624 ths
1748 4b0f1a8b pbrook
                        if (offset)
1749 4b0f1a8b pbrook
                          {
1750 4b0f1a8b pbrook
                            if (!add)
1751 4b0f1a8b pbrook
                              offset = -offset;
1752 4b0f1a8b pbrook
                            func (stream, ", #%d", offset);
1753 4b0f1a8b pbrook
                          }
1754 4b0f1a8b pbrook
                        func (stream, "]");
1755 4b0f1a8b pbrook
                        if (rn == 15)
1756 4b0f1a8b pbrook
                          {
1757 4b0f1a8b pbrook
                            func (stream, "\t; ");
1758 4b0f1a8b pbrook
                            /* FIXME: Unsure if info->bytes_per_chunk is the
1759 4b0f1a8b pbrook
                               right thing to use here.  */
1760 4b0f1a8b pbrook
                            info->print_address_func (offset + pc
1761 4b0f1a8b pbrook
                              + info->bytes_per_chunk * 2, info);
1762 4b0f1a8b pbrook
                          }
1763 4b0f1a8b pbrook
                      }
1764 4b0f1a8b pbrook
                      break;
1765 aa0aa4fa bellard
1766 aa0aa4fa bellard
                    case 'c':
1767 4b0f1a8b pbrook
                      func (stream, "%s", arm_conditional[cond]);
1768 aa0aa4fa bellard
                      break;
1769 aa0aa4fa bellard
1770 aa0aa4fa bellard
                    case 'I':
1771 aa0aa4fa bellard
                      /* Print a Cirrus/DSP shift immediate.  */
1772 aa0aa4fa bellard
                      /* Immediates are 7bit signed ints with bits 0..3 in
1773 aa0aa4fa bellard
                         bits 0..3 of opcode and bits 4..6 in bits 5..7
1774 aa0aa4fa bellard
                         of opcode.  */
1775 aa0aa4fa bellard
                      {
1776 aa0aa4fa bellard
                        int imm;
1777 aa0aa4fa bellard
1778 aa0aa4fa bellard
                        imm = (given & 0xf) | ((given & 0xe0) >> 1);
1779 aa0aa4fa bellard
1780 aa0aa4fa bellard
                        /* Is ``imm'' a negative number?  */
1781 aa0aa4fa bellard
                        if (imm & 0x40)
1782 aa0aa4fa bellard
                          imm |= (-1 << 7);
1783 aa0aa4fa bellard
1784 aa0aa4fa bellard
                        func (stream, "%d", imm);
1785 aa0aa4fa bellard
                      }
1786 aa0aa4fa bellard
1787 aa0aa4fa bellard
                      break;
1788 aa0aa4fa bellard
1789 aa0aa4fa bellard
                    case 'F':
1790 aa0aa4fa bellard
                      switch (given & 0x00408000)
1791 aa0aa4fa bellard
                        {
1792 aa0aa4fa bellard
                        case 0:
1793 aa0aa4fa bellard
                          func (stream, "4");
1794 aa0aa4fa bellard
                          break;
1795 aa0aa4fa bellard
                        case 0x8000:
1796 aa0aa4fa bellard
                          func (stream, "1");
1797 aa0aa4fa bellard
                          break;
1798 aa0aa4fa bellard
                        case 0x00400000:
1799 aa0aa4fa bellard
                          func (stream, "2");
1800 aa0aa4fa bellard
                          break;
1801 aa0aa4fa bellard
                        default:
1802 aa0aa4fa bellard
                          func (stream, "3");
1803 aa0aa4fa bellard
                        }
1804 aa0aa4fa bellard
                      break;
1805 3b46e624 ths
1806 aa0aa4fa bellard
                    case 'P':
1807 aa0aa4fa bellard
                      switch (given & 0x00080080)
1808 aa0aa4fa bellard
                        {
1809 aa0aa4fa bellard
                        case 0:
1810 aa0aa4fa bellard
                          func (stream, "s");
1811 aa0aa4fa bellard
                          break;
1812 aa0aa4fa bellard
                        case 0x80:
1813 aa0aa4fa bellard
                          func (stream, "d");
1814 aa0aa4fa bellard
                          break;
1815 aa0aa4fa bellard
                        case 0x00080000:
1816 aa0aa4fa bellard
                          func (stream, "e");
1817 aa0aa4fa bellard
                          break;
1818 aa0aa4fa bellard
                        default:
1819 aa0aa4fa bellard
                          func (stream, _("<illegal precision>"));
1820 aa0aa4fa bellard
                          break;
1821 aa0aa4fa bellard
                        }
1822 aa0aa4fa bellard
                      break;
1823 aa0aa4fa bellard
                    case 'Q':
1824 aa0aa4fa bellard
                      switch (given & 0x00408000)
1825 aa0aa4fa bellard
                        {
1826 aa0aa4fa bellard
                        case 0:
1827 aa0aa4fa bellard
                          func (stream, "s");
1828 aa0aa4fa bellard
                          break;
1829 aa0aa4fa bellard
                        case 0x8000:
1830 aa0aa4fa bellard
                          func (stream, "d");
1831 aa0aa4fa bellard
                          break;
1832 aa0aa4fa bellard
                        case 0x00400000:
1833 aa0aa4fa bellard
                          func (stream, "e");
1834 aa0aa4fa bellard
                          break;
1835 aa0aa4fa bellard
                        default:
1836 aa0aa4fa bellard
                          func (stream, "p");
1837 aa0aa4fa bellard
                          break;
1838 aa0aa4fa bellard
                        }
1839 aa0aa4fa bellard
                      break;
1840 aa0aa4fa bellard
                    case 'R':
1841 aa0aa4fa bellard
                      switch (given & 0x60)
1842 aa0aa4fa bellard
                        {
1843 aa0aa4fa bellard
                        case 0:
1844 aa0aa4fa bellard
                          break;
1845 aa0aa4fa bellard
                        case 0x20:
1846 aa0aa4fa bellard
                          func (stream, "p");
1847 aa0aa4fa bellard
                          break;
1848 aa0aa4fa bellard
                        case 0x40:
1849 aa0aa4fa bellard
                          func (stream, "m");
1850 aa0aa4fa bellard
                          break;
1851 aa0aa4fa bellard
                        default:
1852 aa0aa4fa bellard
                          func (stream, "z");
1853 aa0aa4fa bellard
                          break;
1854 aa0aa4fa bellard
                        }
1855 aa0aa4fa bellard
                      break;
1856 aa0aa4fa bellard
1857 5fafdf24 ths
                    case '0': case '1': case '2': case '3': case '4':
1858 aa0aa4fa bellard
                    case '5': case '6': case '7': case '8': case '9':
1859 aa0aa4fa bellard
                      {
1860 4b0f1a8b pbrook
                        int width;
1861 4b0f1a8b pbrook
                        unsigned long value;
1862 4b0f1a8b pbrook
1863 4b0f1a8b pbrook
                        c = arm_decode_bitfield (c, given, &value, &width);
1864 aa0aa4fa bellard
1865 aa0aa4fa bellard
                        switch (*c)
1866 aa0aa4fa bellard
                          {
1867 4b0f1a8b pbrook
                          case 'r':
1868 4b0f1a8b pbrook
                            func (stream, "%s", arm_regnames[value]);
1869 4b0f1a8b pbrook
                            break;
1870 4b0f1a8b pbrook
                          case 'D':
1871 4b0f1a8b pbrook
                            func (stream, "d%ld", value);
1872 4b0f1a8b pbrook
                            break;
1873 4b0f1a8b pbrook
                          case 'Q':
1874 4b0f1a8b pbrook
                            if (value & 1)
1875 4b0f1a8b pbrook
                              func (stream, "<illegal reg q%ld.5>", value >> 1);
1876 4b0f1a8b pbrook
                            else
1877 4b0f1a8b pbrook
                              func (stream, "q%ld", value >> 1);
1878 4b0f1a8b pbrook
                            break;
1879 4b0f1a8b pbrook
                          case 'd':
1880 4b0f1a8b pbrook
                            func (stream, "%ld", value);
1881 4b0f1a8b pbrook
                            break;
1882 4b0f1a8b pbrook
                          case 'k':
1883 4b0f1a8b pbrook
                            {
1884 4b0f1a8b pbrook
                              int from = (given & (1 << 7)) ? 32 : 16;
1885 4b0f1a8b pbrook
                              func (stream, "%ld", from - value);
1886 4b0f1a8b pbrook
                            }
1887 4b0f1a8b pbrook
                            break;
1888 4b0f1a8b pbrook
1889 4b0f1a8b pbrook
                          case 'f':
1890 4b0f1a8b pbrook
                            if (value > 7)
1891 4b0f1a8b pbrook
                              func (stream, "#%s", arm_fp_const[value & 7]);
1892 4b0f1a8b pbrook
                            else
1893 4b0f1a8b pbrook
                              func (stream, "f%ld", value);
1894 4b0f1a8b pbrook
                            break;
1895 3b46e624 ths
1896 4b0f1a8b pbrook
                          case 'w':
1897 4b0f1a8b pbrook
                            if (width == 2)
1898 4b0f1a8b pbrook
                              func (stream, "%s", iwmmxt_wwnames[value]);
1899 4b0f1a8b pbrook
                            else
1900 4b0f1a8b pbrook
                              func (stream, "%s", iwmmxt_wwssnames[value]);
1901 4b0f1a8b pbrook
                            break;
1902 3b46e624 ths
1903 4b0f1a8b pbrook
                          case 'g':
1904 4b0f1a8b pbrook
                            func (stream, "%s", iwmmxt_regnames[value]);
1905 4b0f1a8b pbrook
                            break;
1906 4b0f1a8b pbrook
                          case 'G':
1907 4b0f1a8b pbrook
                            func (stream, "%s", iwmmxt_cregnames[value]);
1908 4b0f1a8b pbrook
                            break;
1909 3b46e624 ths
1910 4b0f1a8b pbrook
                          case 'x':
1911 4b0f1a8b pbrook
                            func (stream, "0x%lx", value);
1912 4b0f1a8b pbrook
                            break;
1913 4b0f1a8b pbrook
1914 4b0f1a8b pbrook
                          case '`':
1915 4b0f1a8b pbrook
                            c++;
1916 4b0f1a8b pbrook
                            if (value == 0)
1917 4b0f1a8b pbrook
                              func (stream, "%c", *c);
1918 4b0f1a8b pbrook
                            break;
1919 4b0f1a8b pbrook
                          case '\'':
1920 4b0f1a8b pbrook
                            c++;
1921 4b0f1a8b pbrook
                            if (value == ((1ul << width) - 1))
1922 4b0f1a8b pbrook
                              func (stream, "%c", *c);
1923 4b0f1a8b pbrook
                            break;
1924 4b0f1a8b pbrook
                          case '?':
1925 4b0f1a8b pbrook
                            func (stream, "%c", c[(1 << width) - (int)value]);
1926 4b0f1a8b pbrook
                            c += 1 << width;
1927 4b0f1a8b pbrook
                            break;
1928 4b0f1a8b pbrook
                          default:
1929 4b0f1a8b pbrook
                            abort ();
1930 4b0f1a8b pbrook
                          }
1931 4b0f1a8b pbrook
                        break;
1932 3b46e624 ths
1933 4b0f1a8b pbrook
                      case 'y':
1934 4b0f1a8b pbrook
                      case 'z':
1935 4b0f1a8b pbrook
                        {
1936 4b0f1a8b pbrook
                          int single = *c++ == 'y';
1937 4b0f1a8b pbrook
                          int regno;
1938 3b46e624 ths
1939 4b0f1a8b pbrook
                          switch (*c)
1940 4b0f1a8b pbrook
                            {
1941 4b0f1a8b pbrook
                            case '4': /* Sm pair */
1942 4b0f1a8b pbrook
                              func (stream, "{");
1943 4b0f1a8b pbrook
                              /* Fall through.  */
1944 4b0f1a8b pbrook
                            case '0': /* Sm, Dm */
1945 4b0f1a8b pbrook
                              regno = given & 0x0000000f;
1946 4b0f1a8b pbrook
                              if (single)
1947 aa0aa4fa bellard
                                {
1948 4b0f1a8b pbrook
                                  regno <<= 1;
1949 4b0f1a8b pbrook
                                  regno += (given >> 5) & 1;
1950 4b0f1a8b pbrook
                                }
1951 4b0f1a8b pbrook
                              else
1952 4b0f1a8b pbrook
                                regno += ((given >> 5) & 1) << 4;
1953 4b0f1a8b pbrook
                              break;
1954 3b46e624 ths
1955 4b0f1a8b pbrook
                            case '1': /* Sd, Dd */
1956 4b0f1a8b pbrook
                              regno = (given >> 12) & 0x0000000f;
1957 4b0f1a8b pbrook
                              if (single)
1958 4b0f1a8b pbrook
                                {
1959 4b0f1a8b pbrook
                                  regno <<= 1;
1960 4b0f1a8b pbrook
                                  regno += (given >> 22) & 1;
1961 4b0f1a8b pbrook
                                }
1962 4b0f1a8b pbrook
                              else
1963 4b0f1a8b pbrook
                                regno += ((given >> 22) & 1) << 4;
1964 4b0f1a8b pbrook
                              break;
1965 3b46e624 ths
1966 4b0f1a8b pbrook
                            case '2': /* Sn, Dn */
1967 4b0f1a8b pbrook
                              regno = (given >> 16) & 0x0000000f;
1968 4b0f1a8b pbrook
                              if (single)
1969 4b0f1a8b pbrook
                                {
1970 4b0f1a8b pbrook
                                  regno <<= 1;
1971 4b0f1a8b pbrook
                                  regno += (given >> 7) & 1;
1972 aa0aa4fa bellard
                                }
1973 4b0f1a8b pbrook
                              else
1974 4b0f1a8b pbrook
                                regno += ((given >> 7) & 1) << 4;
1975 4b0f1a8b pbrook
                              break;
1976 4b0f1a8b pbrook
1977 4b0f1a8b pbrook
                            case '3': /* List */
1978 4b0f1a8b pbrook
                              func (stream, "{");
1979 4b0f1a8b pbrook
                              regno = (given >> 12) & 0x0000000f;
1980 4b0f1a8b pbrook
                              if (single)
1981 aa0aa4fa bellard
                                {
1982 4b0f1a8b pbrook
                                  regno <<= 1;
1983 4b0f1a8b pbrook
                                  regno += (given >> 22) & 1;
1984 4b0f1a8b pbrook
                                }
1985 4b0f1a8b pbrook
                              else
1986 4b0f1a8b pbrook
                                regno += ((given >> 22) & 1) << 4;
1987 4b0f1a8b pbrook
                              break;
1988 3b46e624 ths
1989 4b0f1a8b pbrook
                            default:
1990 4b0f1a8b pbrook
                              abort ();
1991 4b0f1a8b pbrook
                            }
1992 3b46e624 ths
1993 4b0f1a8b pbrook
                          func (stream, "%c%d", single ? 's' : 'd', regno);
1994 3b46e624 ths
1995 4b0f1a8b pbrook
                          if (*c == '3')
1996 4b0f1a8b pbrook
                            {
1997 4b0f1a8b pbrook
                              int count = given & 0xff;
1998 3b46e624 ths
1999 4b0f1a8b pbrook
                              if (single == 0)
2000 4b0f1a8b pbrook
                                count >>= 1;
2001 3b46e624 ths
2002 4b0f1a8b pbrook
                              if (--count)
2003 aa0aa4fa bellard
                                {
2004 4b0f1a8b pbrook
                                  func (stream, "-%c%d",
2005 4b0f1a8b pbrook
                                        single ? 's' : 'd',
2006 4b0f1a8b pbrook
                                        regno + count);
2007 4b0f1a8b pbrook
                                }
2008 3b46e624 ths
2009 4b0f1a8b pbrook
                              func (stream, "}");
2010 4b0f1a8b pbrook
                            }
2011 4b0f1a8b pbrook
                          else if (*c == '4')
2012 4b0f1a8b pbrook
                            func (stream, ", %c%d}", single ? 's' : 'd',
2013 4b0f1a8b pbrook
                                  regno + 1);
2014 4b0f1a8b pbrook
                        }
2015 4b0f1a8b pbrook
                        break;
2016 3b46e624 ths
2017 4b0f1a8b pbrook
                      case 'L':
2018 4b0f1a8b pbrook
                        switch (given & 0x00400100)
2019 4b0f1a8b pbrook
                          {
2020 4b0f1a8b pbrook
                          case 0x00000000: func (stream, "b"); break;
2021 4b0f1a8b pbrook
                          case 0x00400000: func (stream, "h"); break;
2022 4b0f1a8b pbrook
                          case 0x00000100: func (stream, "w"); break;
2023 4b0f1a8b pbrook
                          case 0x00400100: func (stream, "d"); break;
2024 4b0f1a8b pbrook
                          default:
2025 aa0aa4fa bellard
                            break;
2026 4b0f1a8b pbrook
                          }
2027 4b0f1a8b pbrook
                        break;
2028 aa0aa4fa bellard
2029 4b0f1a8b pbrook
                      case 'Z':
2030 4b0f1a8b pbrook
                        {
2031 4b0f1a8b pbrook
                          int value;
2032 4b0f1a8b pbrook
                          /* given (20, 23) | given (0, 3) */
2033 4b0f1a8b pbrook
                          value = ((given >> 16) & 0xf0) | (given & 0xf);
2034 4b0f1a8b pbrook
                          func (stream, "%d", value);
2035 4b0f1a8b pbrook
                        }
2036 4b0f1a8b pbrook
                        break;
2037 aa0aa4fa bellard
2038 4b0f1a8b pbrook
                      case 'l':
2039 4b0f1a8b pbrook
                        /* This is like the 'A' operator, except that if
2040 4b0f1a8b pbrook
                           the width field "M" is zero, then the offset is
2041 4b0f1a8b pbrook
                           *not* multiplied by four.  */
2042 4b0f1a8b pbrook
                        {
2043 4b0f1a8b pbrook
                          int offset = given & 0xff;
2044 4b0f1a8b pbrook
                          int multiplier = (given & 0x00000100) ? 4 : 1;
2045 aa0aa4fa bellard
2046 4b0f1a8b pbrook
                          func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
2047 aa0aa4fa bellard
2048 4b0f1a8b pbrook
                          if (offset)
2049 4b0f1a8b pbrook
                            {
2050 4b0f1a8b pbrook
                              if ((given & 0x01000000) != 0)
2051 4b0f1a8b pbrook
                                func (stream, ", #%s%d]%s",
2052 4b0f1a8b pbrook
                                      ((given & 0x00800000) == 0 ? "-" : ""),
2053 4b0f1a8b pbrook
                                      offset * multiplier,
2054 4b0f1a8b pbrook
                                      ((given & 0x00200000) != 0 ? "!" : ""));
2055 4b0f1a8b pbrook
                              else
2056 4b0f1a8b pbrook
                                func (stream, "], #%s%d",
2057 4b0f1a8b pbrook
                                      ((given & 0x00800000) == 0 ? "-" : ""),
2058 4b0f1a8b pbrook
                                      offset * multiplier);
2059 4b0f1a8b pbrook
                            }
2060 4b0f1a8b pbrook
                          else
2061 4b0f1a8b pbrook
                            func (stream, "]");
2062 4b0f1a8b pbrook
                        }
2063 4b0f1a8b pbrook
                        break;
2064 aa0aa4fa bellard
2065 4b0f1a8b pbrook
                      case 'r':
2066 4b0f1a8b pbrook
                        {
2067 4b0f1a8b pbrook
                          int imm4 = (given >> 4) & 0xf;
2068 4b0f1a8b pbrook
                          int puw_bits = ((given >> 22) & 6) | ((given >> 21) & 1);
2069 4b0f1a8b pbrook
                          int ubit = (given >> 23) & 1;
2070 4b0f1a8b pbrook
                          const char *rm = arm_regnames [given & 0xf];
2071 4b0f1a8b pbrook
                          const char *rn = arm_regnames [(given >> 16) & 0xf];
2072 aa0aa4fa bellard
2073 4b0f1a8b pbrook
                          switch (puw_bits)
2074 4b0f1a8b pbrook
                            {
2075 4b0f1a8b pbrook
                            case 1:
2076 4b0f1a8b pbrook
                              /* fall through */
2077 4b0f1a8b pbrook
                            case 3:
2078 4b0f1a8b pbrook
                              func (stream, "[%s], %c%s", rn, ubit ? '+' : '-', rm);
2079 4b0f1a8b pbrook
                              if (imm4)
2080 4b0f1a8b pbrook
                                func (stream, ", lsl #%d", imm4);
2081 4b0f1a8b pbrook
                              break;
2082 aa0aa4fa bellard
2083 4b0f1a8b pbrook
                            case 4:
2084 4b0f1a8b pbrook
                              /* fall through */
2085 4b0f1a8b pbrook
                            case 5:
2086 4b0f1a8b pbrook
                              /* fall through */
2087 4b0f1a8b pbrook
                            case 6:
2088 4b0f1a8b pbrook
                              /* fall through */
2089 4b0f1a8b pbrook
                            case 7:
2090 4b0f1a8b pbrook
                              func (stream, "[%s, %c%s", rn, ubit ? '+' : '-', rm);
2091 4b0f1a8b pbrook
                              if (imm4 > 0)
2092 4b0f1a8b pbrook
                                func (stream, ", lsl #%d", imm4);
2093 4b0f1a8b pbrook
                              func (stream, "]");
2094 4b0f1a8b pbrook
                              if (puw_bits == 5 || puw_bits == 7)
2095 4b0f1a8b pbrook
                                func (stream, "!");
2096 aa0aa4fa bellard
                              break;
2097 4b0f1a8b pbrook
2098 4b0f1a8b pbrook
                            default:
2099 4b0f1a8b pbrook
                              func (stream, "INVALID");
2100 aa0aa4fa bellard
                            }
2101 4b0f1a8b pbrook
                        }
2102 4b0f1a8b pbrook
                        break;
2103 aa0aa4fa bellard
2104 4b0f1a8b pbrook
                      case 'i':
2105 4b0f1a8b pbrook
                        {
2106 4b0f1a8b pbrook
                          long imm5;
2107 4b0f1a8b pbrook
                          imm5 = ((given & 0x100) >> 4) | (given & 0xf);
2108 4b0f1a8b pbrook
                          func (stream, "%ld", (imm5 == 0) ? 32 : imm5);
2109 4b0f1a8b pbrook
                        }
2110 aa0aa4fa bellard
                        break;
2111 aa0aa4fa bellard
2112 aa0aa4fa bellard
                      default:
2113 aa0aa4fa bellard
                        abort ();
2114 aa0aa4fa bellard
                      }
2115 aa0aa4fa bellard
                    }
2116 aa0aa4fa bellard
                }
2117 aa0aa4fa bellard
              else
2118 aa0aa4fa bellard
                func (stream, "%c", *c);
2119 aa0aa4fa bellard
            }
2120 47cbc7aa Juan Quintela
          return true;
2121 aa0aa4fa bellard
        }
2122 aa0aa4fa bellard
    }
2123 47cbc7aa Juan Quintela
  return false;
2124 aa0aa4fa bellard
}
2125 aa0aa4fa bellard
2126 4b0f1a8b pbrook
static void
2127 4b0f1a8b pbrook
print_arm_address (bfd_vma pc, struct disassemble_info *info, long given)
2128 aa0aa4fa bellard
{
2129 4b0f1a8b pbrook
  void *stream = info->stream;
2130 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
2131 aa0aa4fa bellard
2132 4b0f1a8b pbrook
  if (((given & 0x000f0000) == 0x000f0000)
2133 4b0f1a8b pbrook
      && ((given & 0x02000000) == 0))
2134 aa0aa4fa bellard
    {
2135 4b0f1a8b pbrook
      int offset = given & 0xfff;
2136 aa0aa4fa bellard
2137 4b0f1a8b pbrook
      func (stream, "[pc");
2138 3b46e624 ths
2139 4b0f1a8b pbrook
      if (given & 0x01000000)
2140 4b0f1a8b pbrook
        {
2141 4b0f1a8b pbrook
          if ((given & 0x00800000) == 0)
2142 4b0f1a8b pbrook
            offset = - offset;
2143 aa0aa4fa bellard
2144 4b0f1a8b pbrook
          /* Pre-indexed.  */
2145 4b0f1a8b pbrook
          func (stream, ", #%d]", offset);
2146 3b46e624 ths
2147 4b0f1a8b pbrook
          offset += pc + 8;
2148 3b46e624 ths
2149 4b0f1a8b pbrook
          /* Cope with the possibility of write-back
2150 4b0f1a8b pbrook
             being used.  Probably a very dangerous thing
2151 4b0f1a8b pbrook
             for the programmer to do, but who are we to
2152 4b0f1a8b pbrook
             argue ?  */
2153 4b0f1a8b pbrook
          if (given & 0x00200000)
2154 4b0f1a8b pbrook
            func (stream, "!");
2155 4b0f1a8b pbrook
        }
2156 4b0f1a8b pbrook
      else
2157 4b0f1a8b pbrook
        {
2158 4b0f1a8b pbrook
          /* Post indexed.  */
2159 4b0f1a8b pbrook
          func (stream, "], #%d", offset);
2160 3b46e624 ths
2161 4b0f1a8b pbrook
          /* ie ignore the offset.  */
2162 4b0f1a8b pbrook
          offset = pc + 8;
2163 4b0f1a8b pbrook
        }
2164 3b46e624 ths
2165 4b0f1a8b pbrook
      func (stream, "\t; ");
2166 4b0f1a8b pbrook
      info->print_address_func (offset, info);
2167 4b0f1a8b pbrook
    }
2168 4b0f1a8b pbrook
  else
2169 4b0f1a8b pbrook
    {
2170 4b0f1a8b pbrook
      func (stream, "[%s",
2171 4b0f1a8b pbrook
            arm_regnames[(given >> 16) & 0xf]);
2172 4b0f1a8b pbrook
      if ((given & 0x01000000) != 0)
2173 4b0f1a8b pbrook
        {
2174 4b0f1a8b pbrook
          if ((given & 0x02000000) == 0)
2175 4b0f1a8b pbrook
            {
2176 4b0f1a8b pbrook
              int offset = given & 0xfff;
2177 4b0f1a8b pbrook
              if (offset)
2178 4b0f1a8b pbrook
                func (stream, ", #%s%d",
2179 4b0f1a8b pbrook
                      (((given & 0x00800000) == 0)
2180 4b0f1a8b pbrook
                       ? "-" : ""), offset);
2181 4b0f1a8b pbrook
            }
2182 4b0f1a8b pbrook
          else
2183 4b0f1a8b pbrook
            {
2184 4b0f1a8b pbrook
              func (stream, ", %s",
2185 4b0f1a8b pbrook
                    (((given & 0x00800000) == 0)
2186 4b0f1a8b pbrook
                     ? "-" : ""));
2187 4b0f1a8b pbrook
              arm_decode_shift (given, func, stream, 1);
2188 4b0f1a8b pbrook
            }
2189 aa0aa4fa bellard
2190 4b0f1a8b pbrook
          func (stream, "]%s",
2191 4b0f1a8b pbrook
                ((given & 0x00200000) != 0) ? "!" : "");
2192 4b0f1a8b pbrook
        }
2193 4b0f1a8b pbrook
      else
2194 4b0f1a8b pbrook
        {
2195 4b0f1a8b pbrook
          if ((given & 0x02000000) == 0)
2196 4b0f1a8b pbrook
            {
2197 4b0f1a8b pbrook
              int offset = given & 0xfff;
2198 4b0f1a8b pbrook
              if (offset)
2199 4b0f1a8b pbrook
                func (stream, "], #%s%d",
2200 4b0f1a8b pbrook
                      (((given & 0x00800000) == 0)
2201 4b0f1a8b pbrook
                       ? "-" : ""), offset);
2202 4b0f1a8b pbrook
              else
2203 4b0f1a8b pbrook
                func (stream, "]");
2204 4b0f1a8b pbrook
            }
2205 4b0f1a8b pbrook
          else
2206 4b0f1a8b pbrook
            {
2207 4b0f1a8b pbrook
              func (stream, "], %s",
2208 4b0f1a8b pbrook
                    (((given & 0x00800000) == 0)
2209 4b0f1a8b pbrook
                     ? "-" : ""));
2210 4b0f1a8b pbrook
              arm_decode_shift (given, func, stream, 1);
2211 4b0f1a8b pbrook
            }
2212 4b0f1a8b pbrook
        }
2213 4b0f1a8b pbrook
    }
2214 4b0f1a8b pbrook
}
2215 4b0f1a8b pbrook
2216 4b0f1a8b pbrook
/* Print one neon instruction on INFO->STREAM.
2217 47cbc7aa Juan Quintela
   Return true if the instuction matched, false if this is not a
2218 4b0f1a8b pbrook
   recognised neon instruction.  */
2219 4b0f1a8b pbrook
2220 4b0f1a8b pbrook
static bfd_boolean
2221 4b0f1a8b pbrook
print_insn_neon (struct disassemble_info *info, long given, bfd_boolean thumb)
2222 4b0f1a8b pbrook
{
2223 4b0f1a8b pbrook
  const struct opcode32 *insn;
2224 4b0f1a8b pbrook
  void *stream = info->stream;
2225 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
2226 4b0f1a8b pbrook
2227 4b0f1a8b pbrook
  if (thumb)
2228 4b0f1a8b pbrook
    {
2229 4b0f1a8b pbrook
      if ((given & 0xef000000) == 0xef000000)
2230 4b0f1a8b pbrook
        {
2231 4b0f1a8b pbrook
          /* move bit 28 to bit 24 to translate Thumb2 to ARM encoding.  */
2232 4b0f1a8b pbrook
          unsigned long bit28 = given & (1 << 28);
2233 4b0f1a8b pbrook
2234 4b0f1a8b pbrook
          given &= 0x00ffffff;
2235 4b0f1a8b pbrook
          if (bit28)
2236 4b0f1a8b pbrook
            given |= 0xf3000000;
2237 4b0f1a8b pbrook
          else
2238 4b0f1a8b pbrook
            given |= 0xf2000000;
2239 4b0f1a8b pbrook
        }
2240 4b0f1a8b pbrook
      else if ((given & 0xff000000) == 0xf9000000)
2241 4b0f1a8b pbrook
        given ^= 0xf9000000 ^ 0xf4000000;
2242 4b0f1a8b pbrook
      else
2243 47cbc7aa Juan Quintela
        return false;
2244 4b0f1a8b pbrook
    }
2245 4b0f1a8b pbrook
2246 4b0f1a8b pbrook
  for (insn = neon_opcodes; insn->assembler; insn++)
2247 4b0f1a8b pbrook
    {
2248 4b0f1a8b pbrook
      if ((given & insn->mask) == insn->value)
2249 4b0f1a8b pbrook
        {
2250 4b0f1a8b pbrook
          const char *c;
2251 4b0f1a8b pbrook
2252 4b0f1a8b pbrook
          for (c = insn->assembler; *c; c++)
2253 4b0f1a8b pbrook
            {
2254 4b0f1a8b pbrook
              if (*c == '%')
2255 4b0f1a8b pbrook
                {
2256 4b0f1a8b pbrook
                  switch (*++c)
2257 4b0f1a8b pbrook
                    {
2258 4b0f1a8b pbrook
                    case '%':
2259 4b0f1a8b pbrook
                      func (stream, "%%");
2260 4b0f1a8b pbrook
                      break;
2261 4b0f1a8b pbrook
2262 4b0f1a8b pbrook
                    case 'c':
2263 4b0f1a8b pbrook
                      if (thumb && ifthen_state)
2264 4b0f1a8b pbrook
                        func (stream, "%s", arm_conditional[IFTHEN_COND]);
2265 4b0f1a8b pbrook
                      break;
2266 4b0f1a8b pbrook
2267 4b0f1a8b pbrook
                    case 'A':
2268 4b0f1a8b pbrook
                      {
2269 4b0f1a8b pbrook
                        static const unsigned char enc[16] =
2270 4b0f1a8b pbrook
                        {
2271 4b0f1a8b pbrook
                          0x4, 0x14, /* st4 0,1 */
2272 4b0f1a8b pbrook
                          0x4, /* st1 2 */
2273 4b0f1a8b pbrook
                          0x4, /* st2 3 */
2274 4b0f1a8b pbrook
                          0x3, /* st3 4 */
2275 4b0f1a8b pbrook
                          0x13, /* st3 5 */
2276 4b0f1a8b pbrook
                          0x3, /* st1 6 */
2277 4b0f1a8b pbrook
                          0x1, /* st1 7 */
2278 4b0f1a8b pbrook
                          0x2, /* st2 8 */
2279 4b0f1a8b pbrook
                          0x12, /* st2 9 */
2280 4b0f1a8b pbrook
                          0x2, /* st1 10 */
2281 4b0f1a8b pbrook
                          0, 0, 0, 0, 0
2282 4b0f1a8b pbrook
                        };
2283 4b0f1a8b pbrook
                        int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2284 4b0f1a8b pbrook
                        int rn = ((given >> 16) & 0xf);
2285 4b0f1a8b pbrook
                        int rm = ((given >> 0) & 0xf);
2286 4b0f1a8b pbrook
                        int align = ((given >> 4) & 0x3);
2287 4b0f1a8b pbrook
                        int type = ((given >> 8) & 0xf);
2288 4b0f1a8b pbrook
                        int n = enc[type] & 0xf;
2289 4b0f1a8b pbrook
                        int stride = (enc[type] >> 4) + 1;
2290 4b0f1a8b pbrook
                        int ix;
2291 4b0f1a8b pbrook
2292 4b0f1a8b pbrook
                        func (stream, "{");
2293 4b0f1a8b pbrook
                        if (stride > 1)
2294 4b0f1a8b pbrook
                          for (ix = 0; ix != n; ix++)
2295 4b0f1a8b pbrook
                            func (stream, "%sd%d", ix ? "," : "", rd + ix * stride);
2296 4b0f1a8b pbrook
                        else if (n == 1)
2297 4b0f1a8b pbrook
                          func (stream, "d%d", rd);
2298 4b0f1a8b pbrook
                        else
2299 4b0f1a8b pbrook
                          func (stream, "d%d-d%d", rd, rd + n - 1);
2300 4b0f1a8b pbrook
                        func (stream, "}, [%s", arm_regnames[rn]);
2301 4b0f1a8b pbrook
                        if (align)
2302 4b0f1a8b pbrook
                          func (stream, ", :%d", 32 << align);
2303 4b0f1a8b pbrook
                        func (stream, "]");
2304 4b0f1a8b pbrook
                        if (rm == 0xd)
2305 4b0f1a8b pbrook
                          func (stream, "!");
2306 4b0f1a8b pbrook
                        else if (rm != 0xf)
2307 4b0f1a8b pbrook
                          func (stream, ", %s", arm_regnames[rm]);
2308 4b0f1a8b pbrook
                      }
2309 4b0f1a8b pbrook
                      break;
2310 4b0f1a8b pbrook
2311 4b0f1a8b pbrook
                    case 'B':
2312 4b0f1a8b pbrook
                      {
2313 4b0f1a8b pbrook
                        int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2314 4b0f1a8b pbrook
                        int rn = ((given >> 16) & 0xf);
2315 4b0f1a8b pbrook
                        int rm = ((given >> 0) & 0xf);
2316 4b0f1a8b pbrook
                        int idx_align = ((given >> 4) & 0xf);
2317 4b0f1a8b pbrook
                        int align = 0;
2318 4b0f1a8b pbrook
                        int size = ((given >> 10) & 0x3);
2319 4b0f1a8b pbrook
                        int idx = idx_align >> (size + 1);
2320 4b0f1a8b pbrook
                        int length = ((given >> 8) & 3) + 1;
2321 4b0f1a8b pbrook
                        int stride = 1;
2322 4b0f1a8b pbrook
                        int i;
2323 4b0f1a8b pbrook
2324 4b0f1a8b pbrook
                        if (length > 1 && size > 0)
2325 4b0f1a8b pbrook
                          stride = (idx_align & (1 << size)) ? 2 : 1;
2326 4b0f1a8b pbrook
2327 4b0f1a8b pbrook
                        switch (length)
2328 4b0f1a8b pbrook
                          {
2329 4b0f1a8b pbrook
                          case 1:
2330 4b0f1a8b pbrook
                            {
2331 4b0f1a8b pbrook
                              int amask = (1 << size) - 1;
2332 4b0f1a8b pbrook
                              if ((idx_align & (1 << size)) != 0)
2333 47cbc7aa Juan Quintela
                                return false;
2334 4b0f1a8b pbrook
                              if (size > 0)
2335 4b0f1a8b pbrook
                                {
2336 4b0f1a8b pbrook
                                  if ((idx_align & amask) == amask)
2337 4b0f1a8b pbrook
                                    align = 8 << size;
2338 4b0f1a8b pbrook
                                  else if ((idx_align & amask) != 0)
2339 47cbc7aa Juan Quintela
                                    return false;
2340 4b0f1a8b pbrook
                                }
2341 4b0f1a8b pbrook
                              }
2342 4b0f1a8b pbrook
                            break;
2343 4b0f1a8b pbrook
2344 4b0f1a8b pbrook
                          case 2:
2345 4b0f1a8b pbrook
                            if (size == 2 && (idx_align & 2) != 0)
2346 47cbc7aa Juan Quintela
                              return false;
2347 4b0f1a8b pbrook
                            align = (idx_align & 1) ? 16 << size : 0;
2348 4b0f1a8b pbrook
                            break;
2349 4b0f1a8b pbrook
2350 4b0f1a8b pbrook
                          case 3:
2351 4b0f1a8b pbrook
                            if ((size == 2 && (idx_align & 3) != 0)
2352 4b0f1a8b pbrook
                                || (idx_align & 1) != 0)
2353 47cbc7aa Juan Quintela
                              return false;
2354 4b0f1a8b pbrook
                            break;
2355 4b0f1a8b pbrook
2356 4b0f1a8b pbrook
                          case 4:
2357 4b0f1a8b pbrook
                            if (size == 2)
2358 4b0f1a8b pbrook
                              {
2359 4b0f1a8b pbrook
                                if ((idx_align & 3) == 3)
2360 47cbc7aa Juan Quintela
                                  return false;
2361 4b0f1a8b pbrook
                                align = (idx_align & 3) * 64;
2362 4b0f1a8b pbrook
                              }
2363 4b0f1a8b pbrook
                            else
2364 4b0f1a8b pbrook
                              align = (idx_align & 1) ? 32 << size : 0;
2365 4b0f1a8b pbrook
                            break;
2366 4b0f1a8b pbrook
2367 4b0f1a8b pbrook
                          default:
2368 4b0f1a8b pbrook
                            abort ();
2369 4b0f1a8b pbrook
                          }
2370 4b0f1a8b pbrook
2371 4b0f1a8b pbrook
                        func (stream, "{");
2372 4b0f1a8b pbrook
                        for (i = 0; i < length; i++)
2373 4b0f1a8b pbrook
                          func (stream, "%sd%d[%d]", (i == 0) ? "" : ",",
2374 4b0f1a8b pbrook
                            rd + i * stride, idx);
2375 4b0f1a8b pbrook
                        func (stream, "}, [%s", arm_regnames[rn]);
2376 4b0f1a8b pbrook
                        if (align)
2377 4b0f1a8b pbrook
                          func (stream, ", :%d", align);
2378 4b0f1a8b pbrook
                        func (stream, "]");
2379 4b0f1a8b pbrook
                        if (rm == 0xd)
2380 4b0f1a8b pbrook
                          func (stream, "!");
2381 4b0f1a8b pbrook
                        else if (rm != 0xf)
2382 4b0f1a8b pbrook
                          func (stream, ", %s", arm_regnames[rm]);
2383 4b0f1a8b pbrook
                      }
2384 4b0f1a8b pbrook
                      break;
2385 4b0f1a8b pbrook
2386 4b0f1a8b pbrook
                    case 'C':
2387 4b0f1a8b pbrook
                      {
2388 4b0f1a8b pbrook
                        int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2389 4b0f1a8b pbrook
                        int rn = ((given >> 16) & 0xf);
2390 4b0f1a8b pbrook
                        int rm = ((given >> 0) & 0xf);
2391 4b0f1a8b pbrook
                        int align = ((given >> 4) & 0x1);
2392 4b0f1a8b pbrook
                        int size = ((given >> 6) & 0x3);
2393 4b0f1a8b pbrook
                        int type = ((given >> 8) & 0x3);
2394 4b0f1a8b pbrook
                        int n = type + 1;
2395 4b0f1a8b pbrook
                        int stride = ((given >> 5) & 0x1);
2396 4b0f1a8b pbrook
                        int ix;
2397 4b0f1a8b pbrook
2398 4b0f1a8b pbrook
                        if (stride && (n == 1))
2399 4b0f1a8b pbrook
                          n++;
2400 4b0f1a8b pbrook
                        else
2401 4b0f1a8b pbrook
                          stride++;
2402 4b0f1a8b pbrook
2403 4b0f1a8b pbrook
                        func (stream, "{");
2404 4b0f1a8b pbrook
                        if (stride > 1)
2405 4b0f1a8b pbrook
                          for (ix = 0; ix != n; ix++)
2406 4b0f1a8b pbrook
                            func (stream, "%sd%d[]", ix ? "," : "", rd + ix * stride);
2407 4b0f1a8b pbrook
                        else if (n == 1)
2408 4b0f1a8b pbrook
                          func (stream, "d%d[]", rd);
2409 4b0f1a8b pbrook
                        else
2410 4b0f1a8b pbrook
                          func (stream, "d%d[]-d%d[]", rd, rd + n - 1);
2411 4b0f1a8b pbrook
                        func (stream, "}, [%s", arm_regnames[rn]);
2412 4b0f1a8b pbrook
                        if (align)
2413 4b0f1a8b pbrook
                          {
2414 4b0f1a8b pbrook
                            int align = (8 * (type + 1)) << size;
2415 4b0f1a8b pbrook
                            if (type == 3)
2416 4b0f1a8b pbrook
                              align = (size > 1) ? align >> 1 : align;
2417 4b0f1a8b pbrook
                            if (type == 2 || (type == 0 && !size))
2418 4b0f1a8b pbrook
                              func (stream, ", :<bad align %d>", align);
2419 4b0f1a8b pbrook
                            else
2420 4b0f1a8b pbrook
                              func (stream, ", :%d", align);
2421 4b0f1a8b pbrook
                          }
2422 4b0f1a8b pbrook
                        func (stream, "]");
2423 4b0f1a8b pbrook
                        if (rm == 0xd)
2424 4b0f1a8b pbrook
                          func (stream, "!");
2425 4b0f1a8b pbrook
                        else if (rm != 0xf)
2426 4b0f1a8b pbrook
                          func (stream, ", %s", arm_regnames[rm]);
2427 4b0f1a8b pbrook
                      }
2428 4b0f1a8b pbrook
                      break;
2429 4b0f1a8b pbrook
2430 4b0f1a8b pbrook
                    case 'D':
2431 4b0f1a8b pbrook
                      {
2432 4b0f1a8b pbrook
                        int raw_reg = (given & 0xf) | ((given >> 1) & 0x10);
2433 4b0f1a8b pbrook
                        int size = (given >> 20) & 3;
2434 4b0f1a8b pbrook
                        int reg = raw_reg & ((4 << size) - 1);
2435 4b0f1a8b pbrook
                        int ix = raw_reg >> size >> 2;
2436 4b0f1a8b pbrook
2437 4b0f1a8b pbrook
                        func (stream, "d%d[%d]", reg, ix);
2438 4b0f1a8b pbrook
                      }
2439 4b0f1a8b pbrook
                      break;
2440 4b0f1a8b pbrook
2441 4b0f1a8b pbrook
                    case 'E':
2442 4b0f1a8b pbrook
                      /* Neon encoded constant for mov, mvn, vorr, vbic */
2443 4b0f1a8b pbrook
                      {
2444 4b0f1a8b pbrook
                        int bits = 0;
2445 4b0f1a8b pbrook
                        int cmode = (given >> 8) & 0xf;
2446 4b0f1a8b pbrook
                        int op = (given >> 5) & 0x1;
2447 4b0f1a8b pbrook
                        unsigned long value = 0, hival = 0;
2448 4b0f1a8b pbrook
                        unsigned shift;
2449 4b0f1a8b pbrook
                        int size = 0;
2450 4b0f1a8b pbrook
                        int isfloat = 0;
2451 4b0f1a8b pbrook
2452 4b0f1a8b pbrook
                        bits |= ((given >> 24) & 1) << 7;
2453 4b0f1a8b pbrook
                        bits |= ((given >> 16) & 7) << 4;
2454 4b0f1a8b pbrook
                        bits |= ((given >> 0) & 15) << 0;
2455 4b0f1a8b pbrook
2456 4b0f1a8b pbrook
                        if (cmode < 8)
2457 4b0f1a8b pbrook
                          {
2458 4b0f1a8b pbrook
                            shift = (cmode >> 1) & 3;
2459 4b0f1a8b pbrook
                            value = (unsigned long)bits << (8 * shift);
2460 4b0f1a8b pbrook
                            size = 32;
2461 4b0f1a8b pbrook
                          }
2462 4b0f1a8b pbrook
                        else if (cmode < 12)
2463 4b0f1a8b pbrook
                          {
2464 4b0f1a8b pbrook
                            shift = (cmode >> 1) & 1;
2465 4b0f1a8b pbrook
                            value = (unsigned long)bits << (8 * shift);
2466 4b0f1a8b pbrook
                            size = 16;
2467 4b0f1a8b pbrook
                          }
2468 4b0f1a8b pbrook
                        else if (cmode < 14)
2469 4b0f1a8b pbrook
                          {
2470 4b0f1a8b pbrook
                            shift = (cmode & 1) + 1;
2471 4b0f1a8b pbrook
                            value = (unsigned long)bits << (8 * shift);
2472 4b0f1a8b pbrook
                            value |= (1ul << (8 * shift)) - 1;
2473 4b0f1a8b pbrook
                            size = 32;
2474 4b0f1a8b pbrook
                          }
2475 4b0f1a8b pbrook
                        else if (cmode == 14)
2476 4b0f1a8b pbrook
                          {
2477 4b0f1a8b pbrook
                            if (op)
2478 4b0f1a8b pbrook
                              {
2479 4b0f1a8b pbrook
                                /* bit replication into bytes */
2480 4b0f1a8b pbrook
                                int ix;
2481 4b0f1a8b pbrook
                                unsigned long mask;
2482 4b0f1a8b pbrook
2483 4b0f1a8b pbrook
                                value = 0;
2484 4b0f1a8b pbrook
                                hival = 0;
2485 4b0f1a8b pbrook
                                for (ix = 7; ix >= 0; ix--)
2486 4b0f1a8b pbrook
                                  {
2487 4b0f1a8b pbrook
                                    mask = ((bits >> ix) & 1) ? 0xff : 0;
2488 4b0f1a8b pbrook
                                    if (ix <= 3)
2489 4b0f1a8b pbrook
                                      value = (value << 8) | mask;
2490 4b0f1a8b pbrook
                                    else
2491 4b0f1a8b pbrook
                                      hival = (hival << 8) | mask;
2492 4b0f1a8b pbrook
                                  }
2493 4b0f1a8b pbrook
                                size = 64;
2494 4b0f1a8b pbrook
                              }
2495 4b0f1a8b pbrook
                            else
2496 4b0f1a8b pbrook
                              {
2497 4b0f1a8b pbrook
                                /* byte replication */
2498 4b0f1a8b pbrook
                                value = (unsigned long)bits;
2499 4b0f1a8b pbrook
                                size = 8;
2500 4b0f1a8b pbrook
                              }
2501 4b0f1a8b pbrook
                          }
2502 4b0f1a8b pbrook
                        else if (!op)
2503 4b0f1a8b pbrook
                          {
2504 4b0f1a8b pbrook
                            /* floating point encoding */
2505 4b0f1a8b pbrook
                            int tmp;
2506 4b0f1a8b pbrook
2507 4b0f1a8b pbrook
                            value = (unsigned long)(bits & 0x7f) << 19;
2508 4b0f1a8b pbrook
                            value |= (unsigned long)(bits & 0x80) << 24;
2509 4b0f1a8b pbrook
                            tmp = bits & 0x40 ? 0x3c : 0x40;
2510 4b0f1a8b pbrook
                            value |= (unsigned long)tmp << 24;
2511 4b0f1a8b pbrook
                            size = 32;
2512 4b0f1a8b pbrook
                            isfloat = 1;
2513 4b0f1a8b pbrook
                          }
2514 4b0f1a8b pbrook
                        else
2515 4b0f1a8b pbrook
                          {
2516 4b0f1a8b pbrook
                            func (stream, "<illegal constant %.8x:%x:%x>",
2517 4b0f1a8b pbrook
                                  bits, cmode, op);
2518 4b0f1a8b pbrook
                            break;
2519 4b0f1a8b pbrook
                          }
2520 4b0f1a8b pbrook
                        switch (size)
2521 4b0f1a8b pbrook
                          {
2522 4b0f1a8b pbrook
                          case 8:
2523 4b0f1a8b pbrook
                            func (stream, "#%ld\t; 0x%.2lx", value, value);
2524 4b0f1a8b pbrook
                            break;
2525 4b0f1a8b pbrook
2526 4b0f1a8b pbrook
                          case 16:
2527 4b0f1a8b pbrook
                            func (stream, "#%ld\t; 0x%.4lx", value, value);
2528 4b0f1a8b pbrook
                            break;
2529 4b0f1a8b pbrook
2530 4b0f1a8b pbrook
                          case 32:
2531 4b0f1a8b pbrook
                            if (isfloat)
2532 4b0f1a8b pbrook
                              {
2533 4b0f1a8b pbrook
                                unsigned char valbytes[4];
2534 4b0f1a8b pbrook
                                double fvalue;
2535 4b0f1a8b pbrook
2536 4b0f1a8b pbrook
                                /* Do this a byte at a time so we don't have to
2537 4b0f1a8b pbrook
                                   worry about the host's endianness.  */
2538 4b0f1a8b pbrook
                                valbytes[0] = value & 0xff;
2539 4b0f1a8b pbrook
                                valbytes[1] = (value >> 8) & 0xff;
2540 4b0f1a8b pbrook
                                valbytes[2] = (value >> 16) & 0xff;
2541 4b0f1a8b pbrook
                                valbytes[3] = (value >> 24) & 0xff;
2542 4b0f1a8b pbrook
2543 e3b283e9 Stefan Weil
                                floatformat_to_double (valbytes, &fvalue);
2544 4b0f1a8b pbrook
2545 4b0f1a8b pbrook
                                func (stream, "#%.7g\t; 0x%.8lx", fvalue,
2546 4b0f1a8b pbrook
                                      value);
2547 4b0f1a8b pbrook
                              }
2548 4b0f1a8b pbrook
                            else
2549 4b0f1a8b pbrook
                              func (stream, "#%ld\t; 0x%.8lx",
2550 4b0f1a8b pbrook
                                (long) ((value & 0x80000000)
2551 4b0f1a8b pbrook
                                        ? value | ~0xffffffffl : value), value);
2552 4b0f1a8b pbrook
                            break;
2553 4b0f1a8b pbrook
2554 4b0f1a8b pbrook
                          case 64:
2555 4b0f1a8b pbrook
                            func (stream, "#0x%.8lx%.8lx", hival, value);
2556 4b0f1a8b pbrook
                            break;
2557 4b0f1a8b pbrook
2558 4b0f1a8b pbrook
                          default:
2559 4b0f1a8b pbrook
                            abort ();
2560 4b0f1a8b pbrook
                          }
2561 4b0f1a8b pbrook
                      }
2562 4b0f1a8b pbrook
                      break;
2563 4b0f1a8b pbrook
2564 4b0f1a8b pbrook
                    case 'F':
2565 4b0f1a8b pbrook
                      {
2566 4b0f1a8b pbrook
                        int regno = ((given >> 16) & 0xf) | ((given >> (7 - 4)) & 0x10);
2567 4b0f1a8b pbrook
                        int num = (given >> 8) & 0x3;
2568 4b0f1a8b pbrook
2569 4b0f1a8b pbrook
                        if (!num)
2570 4b0f1a8b pbrook
                          func (stream, "{d%d}", regno);
2571 4b0f1a8b pbrook
                        else if (num + regno >= 32)
2572 4b0f1a8b pbrook
                          func (stream, "{d%d-<overflow reg d%d}", regno, regno + num);
2573 4b0f1a8b pbrook
                        else
2574 4b0f1a8b pbrook
                          func (stream, "{d%d-d%d}", regno, regno + num);
2575 4b0f1a8b pbrook
                      }
2576 4b0f1a8b pbrook
                      break;
2577 4b0f1a8b pbrook
2578 4b0f1a8b pbrook
2579 4b0f1a8b pbrook
                    case '0': case '1': case '2': case '3': case '4':
2580 4b0f1a8b pbrook
                    case '5': case '6': case '7': case '8': case '9':
2581 4b0f1a8b pbrook
                      {
2582 4b0f1a8b pbrook
                        int width;
2583 4b0f1a8b pbrook
                        unsigned long value;
2584 4b0f1a8b pbrook
2585 4b0f1a8b pbrook
                        c = arm_decode_bitfield (c, given, &value, &width);
2586 4b0f1a8b pbrook
2587 4b0f1a8b pbrook
                        switch (*c)
2588 4b0f1a8b pbrook
                          {
2589 4b0f1a8b pbrook
                          case 'r':
2590 4b0f1a8b pbrook
                            func (stream, "%s", arm_regnames[value]);
2591 4b0f1a8b pbrook
                            break;
2592 4b0f1a8b pbrook
                          case 'd':
2593 4b0f1a8b pbrook
                            func (stream, "%ld", value);
2594 4b0f1a8b pbrook
                            break;
2595 4b0f1a8b pbrook
                          case 'e':
2596 4b0f1a8b pbrook
                            func (stream, "%ld", (1ul << width) - value);
2597 4b0f1a8b pbrook
                            break;
2598 4b0f1a8b pbrook
2599 4b0f1a8b pbrook
                          case 'S':
2600 4b0f1a8b pbrook
                          case 'T':
2601 4b0f1a8b pbrook
                          case 'U':
2602 4b0f1a8b pbrook
                            /* various width encodings */
2603 4b0f1a8b pbrook
                            {
2604 4b0f1a8b pbrook
                              int base = 8 << (*c - 'S'); /* 8,16 or 32 */
2605 4b0f1a8b pbrook
                              int limit;
2606 4b0f1a8b pbrook
                              unsigned low, high;
2607 4b0f1a8b pbrook
2608 4b0f1a8b pbrook
                              c++;
2609 4b0f1a8b pbrook
                              if (*c >= '0' && *c <= '9')
2610 4b0f1a8b pbrook
                                limit = *c - '0';
2611 4b0f1a8b pbrook
                              else if (*c >= 'a' && *c <= 'f')
2612 4b0f1a8b pbrook
                                limit = *c - 'a' + 10;
2613 4b0f1a8b pbrook
                              else
2614 4b0f1a8b pbrook
                                abort ();
2615 4b0f1a8b pbrook
                              low = limit >> 2;
2616 4b0f1a8b pbrook
                              high = limit & 3;
2617 4b0f1a8b pbrook
2618 4b0f1a8b pbrook
                              if (value < low || value > high)
2619 4b0f1a8b pbrook
                                func (stream, "<illegal width %d>", base << value);
2620 4b0f1a8b pbrook
                              else
2621 4b0f1a8b pbrook
                                func (stream, "%d", base << value);
2622 4b0f1a8b pbrook
                            }
2623 4b0f1a8b pbrook
                            break;
2624 4b0f1a8b pbrook
                          case 'R':
2625 4b0f1a8b pbrook
                            if (given & (1 << 6))
2626 4b0f1a8b pbrook
                              goto Q;
2627 4b0f1a8b pbrook
                            /* FALLTHROUGH */
2628 4b0f1a8b pbrook
                          case 'D':
2629 4b0f1a8b pbrook
                            func (stream, "d%ld", value);
2630 4b0f1a8b pbrook
                            break;
2631 4b0f1a8b pbrook
                          case 'Q':
2632 4b0f1a8b pbrook
                          Q:
2633 4b0f1a8b pbrook
                            if (value & 1)
2634 4b0f1a8b pbrook
                              func (stream, "<illegal reg q%ld.5>", value >> 1);
2635 4b0f1a8b pbrook
                            else
2636 4b0f1a8b pbrook
                              func (stream, "q%ld", value >> 1);
2637 4b0f1a8b pbrook
                            break;
2638 4b0f1a8b pbrook
2639 4b0f1a8b pbrook
                          case '`':
2640 4b0f1a8b pbrook
                            c++;
2641 4b0f1a8b pbrook
                            if (value == 0)
2642 4b0f1a8b pbrook
                              func (stream, "%c", *c);
2643 4b0f1a8b pbrook
                            break;
2644 4b0f1a8b pbrook
                          case '\'':
2645 4b0f1a8b pbrook
                            c++;
2646 4b0f1a8b pbrook
                            if (value == ((1ul << width) - 1))
2647 4b0f1a8b pbrook
                              func (stream, "%c", *c);
2648 4b0f1a8b pbrook
                            break;
2649 4b0f1a8b pbrook
                          case '?':
2650 4b0f1a8b pbrook
                            func (stream, "%c", c[(1 << width) - (int)value]);
2651 4b0f1a8b pbrook
                            c += 1 << width;
2652 4b0f1a8b pbrook
                            break;
2653 4b0f1a8b pbrook
                          default:
2654 4b0f1a8b pbrook
                            abort ();
2655 4b0f1a8b pbrook
                          }
2656 4b0f1a8b pbrook
                        break;
2657 4b0f1a8b pbrook
2658 4b0f1a8b pbrook
                      default:
2659 4b0f1a8b pbrook
                        abort ();
2660 4b0f1a8b pbrook
                      }
2661 4b0f1a8b pbrook
                    }
2662 4b0f1a8b pbrook
                }
2663 4b0f1a8b pbrook
              else
2664 4b0f1a8b pbrook
                func (stream, "%c", *c);
2665 4b0f1a8b pbrook
            }
2666 47cbc7aa Juan Quintela
          return true;
2667 4b0f1a8b pbrook
        }
2668 4b0f1a8b pbrook
    }
2669 47cbc7aa Juan Quintela
  return false;
2670 4b0f1a8b pbrook
}
2671 4b0f1a8b pbrook
2672 4b0f1a8b pbrook
/* Print one ARM instruction from PC on INFO->STREAM.  */
2673 4b0f1a8b pbrook
2674 4b0f1a8b pbrook
static void
2675 4b0f1a8b pbrook
print_insn_arm_internal (bfd_vma pc, struct disassemble_info *info, long given)
2676 4b0f1a8b pbrook
{
2677 4b0f1a8b pbrook
  const struct opcode32 *insn;
2678 4b0f1a8b pbrook
  void *stream = info->stream;
2679 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
2680 4b0f1a8b pbrook
2681 47cbc7aa Juan Quintela
  if (print_insn_coprocessor (pc, info, given, false))
2682 4b0f1a8b pbrook
    return;
2683 4b0f1a8b pbrook
2684 47cbc7aa Juan Quintela
  if (print_insn_neon (info, given, false))
2685 4b0f1a8b pbrook
    return;
2686 4b0f1a8b pbrook
2687 4b0f1a8b pbrook
  for (insn = arm_opcodes; insn->assembler; insn++)
2688 4b0f1a8b pbrook
    {
2689 4b0f1a8b pbrook
      if (insn->value == FIRST_IWMMXT_INSN
2690 4b0f1a8b pbrook
          && info->mach != bfd_mach_arm_XScale
2691 4b0f1a8b pbrook
          && info->mach != bfd_mach_arm_iWMMXt)
2692 4b0f1a8b pbrook
        insn = insn + IWMMXT_INSN_COUNT;
2693 4b0f1a8b pbrook
2694 4b0f1a8b pbrook
      if ((given & insn->mask) == insn->value
2695 4b0f1a8b pbrook
          /* Special case: an instruction with all bits set in the condition field
2696 4b0f1a8b pbrook
             (0xFnnn_nnnn) is only matched if all those bits are set in insn->mask,
2697 4b0f1a8b pbrook
             or by the catchall at the end of the table.  */
2698 4b0f1a8b pbrook
          && ((given & 0xF0000000) != 0xF0000000
2699 4b0f1a8b pbrook
              || (insn->mask & 0xF0000000) == 0xF0000000
2700 4b0f1a8b pbrook
              || (insn->mask == 0 && insn->value == 0)))
2701 4b0f1a8b pbrook
        {
2702 4b0f1a8b pbrook
          const char *c;
2703 4b0f1a8b pbrook
2704 4b0f1a8b pbrook
          for (c = insn->assembler; *c; c++)
2705 4b0f1a8b pbrook
            {
2706 4b0f1a8b pbrook
              if (*c == '%')
2707 4b0f1a8b pbrook
                {
2708 4b0f1a8b pbrook
                  switch (*++c)
2709 4b0f1a8b pbrook
                    {
2710 4b0f1a8b pbrook
                    case '%':
2711 4b0f1a8b pbrook
                      func (stream, "%%");
2712 4b0f1a8b pbrook
                      break;
2713 4b0f1a8b pbrook
2714 4b0f1a8b pbrook
                    case 'a':
2715 4b0f1a8b pbrook
                      print_arm_address (pc, info, given);
2716 4b0f1a8b pbrook
                      break;
2717 4b0f1a8b pbrook
2718 4b0f1a8b pbrook
                    case 'P':
2719 4b0f1a8b pbrook
                      /* Set P address bit and use normal address
2720 4b0f1a8b pbrook
                         printing routine.  */
2721 4b0f1a8b pbrook
                      print_arm_address (pc, info, given | (1 << 24));
2722 4b0f1a8b pbrook
                      break;
2723 4b0f1a8b pbrook
2724 4b0f1a8b pbrook
                    case 's':
2725 4b0f1a8b pbrook
                      if ((given & 0x004f0000) == 0x004f0000)
2726 4b0f1a8b pbrook
                        {
2727 4b0f1a8b pbrook
                          /* PC relative with immediate offset.  */
2728 4b0f1a8b pbrook
                          int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2729 4b0f1a8b pbrook
2730 4b0f1a8b pbrook
                          if ((given & 0x00800000) == 0)
2731 4b0f1a8b pbrook
                            offset = -offset;
2732 4b0f1a8b pbrook
2733 4b0f1a8b pbrook
                          func (stream, "[pc, #%d]\t; ", offset);
2734 4b0f1a8b pbrook
                          info->print_address_func (offset + pc + 8, info);
2735 4b0f1a8b pbrook
                        }
2736 4b0f1a8b pbrook
                      else
2737 4b0f1a8b pbrook
                        {
2738 4b0f1a8b pbrook
                          func (stream, "[%s",
2739 4b0f1a8b pbrook
                                arm_regnames[(given >> 16) & 0xf]);
2740 4b0f1a8b pbrook
                          if ((given & 0x01000000) != 0)
2741 4b0f1a8b pbrook
                            {
2742 4b0f1a8b pbrook
                              /* Pre-indexed.  */
2743 4b0f1a8b pbrook
                              if ((given & 0x00400000) == 0x00400000)
2744 4b0f1a8b pbrook
                                {
2745 4b0f1a8b pbrook
                                  /* Immediate.  */
2746 4b0f1a8b pbrook
                                  int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2747 4b0f1a8b pbrook
                                  if (offset)
2748 4b0f1a8b pbrook
                                    func (stream, ", #%s%d",
2749 4b0f1a8b pbrook
                                          (((given & 0x00800000) == 0)
2750 4b0f1a8b pbrook
                                           ? "-" : ""), offset);
2751 4b0f1a8b pbrook
                                }
2752 4b0f1a8b pbrook
                              else
2753 4b0f1a8b pbrook
                                {
2754 4b0f1a8b pbrook
                                  /* Register.  */
2755 4b0f1a8b pbrook
                                  func (stream, ", %s%s",
2756 4b0f1a8b pbrook
                                        (((given & 0x00800000) == 0)
2757 4b0f1a8b pbrook
                                         ? "-" : ""),
2758 4b0f1a8b pbrook
                                        arm_regnames[given & 0xf]);
2759 4b0f1a8b pbrook
                                }
2760 4b0f1a8b pbrook
2761 4b0f1a8b pbrook
                              func (stream, "]%s",
2762 4b0f1a8b pbrook
                                    ((given & 0x00200000) != 0) ? "!" : "");
2763 4b0f1a8b pbrook
                            }
2764 4b0f1a8b pbrook
                          else
2765 4b0f1a8b pbrook
                            {
2766 4b0f1a8b pbrook
                              /* Post-indexed.  */
2767 4b0f1a8b pbrook
                              if ((given & 0x00400000) == 0x00400000)
2768 4b0f1a8b pbrook
                                {
2769 4b0f1a8b pbrook
                                  /* Immediate.  */
2770 4b0f1a8b pbrook
                                  int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2771 4b0f1a8b pbrook
                                  if (offset)
2772 4b0f1a8b pbrook
                                    func (stream, "], #%s%d",
2773 4b0f1a8b pbrook
                                          (((given & 0x00800000) == 0)
2774 4b0f1a8b pbrook
                                           ? "-" : ""), offset);
2775 4b0f1a8b pbrook
                                  else
2776 4b0f1a8b pbrook
                                    func (stream, "]");
2777 4b0f1a8b pbrook
                                }
2778 4b0f1a8b pbrook
                              else
2779 4b0f1a8b pbrook
                                {
2780 4b0f1a8b pbrook
                                  /* Register.  */
2781 4b0f1a8b pbrook
                                  func (stream, "], %s%s",
2782 4b0f1a8b pbrook
                                        (((given & 0x00800000) == 0)
2783 4b0f1a8b pbrook
                                         ? "-" : ""),
2784 4b0f1a8b pbrook
                                        arm_regnames[given & 0xf]);
2785 4b0f1a8b pbrook
                                }
2786 4b0f1a8b pbrook
                            }
2787 4b0f1a8b pbrook
                        }
2788 4b0f1a8b pbrook
                      break;
2789 4b0f1a8b pbrook
2790 4b0f1a8b pbrook
                    case 'b':
2791 4b0f1a8b pbrook
                      {
2792 4b0f1a8b pbrook
                        int disp = (((given & 0xffffff) ^ 0x800000) - 0x800000);
2793 4b0f1a8b pbrook
                        info->print_address_func (disp*4 + pc + 8, info);
2794 4b0f1a8b pbrook
                      }
2795 4b0f1a8b pbrook
                      break;
2796 4b0f1a8b pbrook
2797 4b0f1a8b pbrook
                    case 'c':
2798 4b0f1a8b pbrook
                      if (((given >> 28) & 0xf) != 0xe)
2799 4b0f1a8b pbrook
                        func (stream, "%s",
2800 4b0f1a8b pbrook
                              arm_conditional [(given >> 28) & 0xf]);
2801 4b0f1a8b pbrook
                      break;
2802 4b0f1a8b pbrook
2803 4b0f1a8b pbrook
                    case 'm':
2804 4b0f1a8b pbrook
                      {
2805 4b0f1a8b pbrook
                        int started = 0;
2806 4b0f1a8b pbrook
                        int reg;
2807 4b0f1a8b pbrook
2808 4b0f1a8b pbrook
                        func (stream, "{");
2809 4b0f1a8b pbrook
                        for (reg = 0; reg < 16; reg++)
2810 4b0f1a8b pbrook
                          if ((given & (1 << reg)) != 0)
2811 4b0f1a8b pbrook
                            {
2812 4b0f1a8b pbrook
                              if (started)
2813 4b0f1a8b pbrook
                                func (stream, ", ");
2814 4b0f1a8b pbrook
                              started = 1;
2815 4b0f1a8b pbrook
                              func (stream, "%s", arm_regnames[reg]);
2816 4b0f1a8b pbrook
                            }
2817 4b0f1a8b pbrook
                        func (stream, "}");
2818 4b0f1a8b pbrook
                      }
2819 4b0f1a8b pbrook
                      break;
2820 4b0f1a8b pbrook
2821 4b0f1a8b pbrook
                    case 'q':
2822 4b0f1a8b pbrook
                      arm_decode_shift (given, func, stream, 0);
2823 4b0f1a8b pbrook
                      break;
2824 4b0f1a8b pbrook
2825 4b0f1a8b pbrook
                    case 'o':
2826 4b0f1a8b pbrook
                      if ((given & 0x02000000) != 0)
2827 4b0f1a8b pbrook
                        {
2828 4b0f1a8b pbrook
                          int rotate = (given & 0xf00) >> 7;
2829 4b0f1a8b pbrook
                          int immed = (given & 0xff);
2830 4b0f1a8b pbrook
                          immed = (((immed << (32 - rotate))
2831 4b0f1a8b pbrook
                                    | (immed >> rotate)) & 0xffffffff);
2832 4b0f1a8b pbrook
                          func (stream, "#%d\t; 0x%x", immed, immed);
2833 4b0f1a8b pbrook
                        }
2834 4b0f1a8b pbrook
                      else
2835 4b0f1a8b pbrook
                        arm_decode_shift (given, func, stream, 1);
2836 4b0f1a8b pbrook
                      break;
2837 4b0f1a8b pbrook
2838 4b0f1a8b pbrook
                    case 'p':
2839 4b0f1a8b pbrook
                      if ((given & 0x0000f000) == 0x0000f000)
2840 4b0f1a8b pbrook
                        func (stream, "p");
2841 4b0f1a8b pbrook
                      break;
2842 4b0f1a8b pbrook
2843 4b0f1a8b pbrook
                    case 't':
2844 4b0f1a8b pbrook
                      if ((given & 0x01200000) == 0x00200000)
2845 4b0f1a8b pbrook
                        func (stream, "t");
2846 4b0f1a8b pbrook
                      break;
2847 4b0f1a8b pbrook
2848 4b0f1a8b pbrook
                    case 'A':
2849 4b0f1a8b pbrook
                      func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
2850 4b0f1a8b pbrook
2851 4b0f1a8b pbrook
                      if ((given & (1 << 24)) != 0)
2852 4b0f1a8b pbrook
                        {
2853 4b0f1a8b pbrook
                          int offset = given & 0xff;
2854 4b0f1a8b pbrook
2855 4b0f1a8b pbrook
                          if (offset)
2856 4b0f1a8b pbrook
                            func (stream, ", #%s%d]%s",
2857 4b0f1a8b pbrook
                                  ((given & 0x00800000) == 0 ? "-" : ""),
2858 4b0f1a8b pbrook
                                  offset * 4,
2859 4b0f1a8b pbrook
                                  ((given & 0x00200000) != 0 ? "!" : ""));
2860 4b0f1a8b pbrook
                          else
2861 4b0f1a8b pbrook
                            func (stream, "]");
2862 4b0f1a8b pbrook
                        }
2863 4b0f1a8b pbrook
                      else
2864 4b0f1a8b pbrook
                        {
2865 4b0f1a8b pbrook
                          int offset = given & 0xff;
2866 4b0f1a8b pbrook
2867 4b0f1a8b pbrook
                          func (stream, "]");
2868 4b0f1a8b pbrook
2869 4b0f1a8b pbrook
                          if (given & (1 << 21))
2870 4b0f1a8b pbrook
                            {
2871 4b0f1a8b pbrook
                              if (offset)
2872 4b0f1a8b pbrook
                                func (stream, ", #%s%d",
2873 4b0f1a8b pbrook
                                      ((given & 0x00800000) == 0 ? "-" : ""),
2874 4b0f1a8b pbrook
                                      offset * 4);
2875 4b0f1a8b pbrook
                            }
2876 4b0f1a8b pbrook
                          else
2877 4b0f1a8b pbrook
                            func (stream, ", {%d}", offset);
2878 4b0f1a8b pbrook
                        }
2879 4b0f1a8b pbrook
                      break;
2880 4b0f1a8b pbrook
2881 4b0f1a8b pbrook
                    case 'B':
2882 4b0f1a8b pbrook
                      /* Print ARM V5 BLX(1) address: pc+25 bits.  */
2883 4b0f1a8b pbrook
                      {
2884 4b0f1a8b pbrook
                        bfd_vma address;
2885 4b0f1a8b pbrook
                        bfd_vma offset = 0;
2886 4b0f1a8b pbrook
2887 4b0f1a8b pbrook
                        if (given & 0x00800000)
2888 4b0f1a8b pbrook
                          /* Is signed, hi bits should be ones.  */
2889 4b0f1a8b pbrook
                          offset = (-1) ^ 0x00ffffff;
2890 4b0f1a8b pbrook
2891 4b0f1a8b pbrook
                        /* Offset is (SignExtend(offset field)<<2).  */
2892 4b0f1a8b pbrook
                        offset += given & 0x00ffffff;
2893 4b0f1a8b pbrook
                        offset <<= 2;
2894 4b0f1a8b pbrook
                        address = offset + pc + 8;
2895 4b0f1a8b pbrook
2896 4b0f1a8b pbrook
                        if (given & 0x01000000)
2897 4b0f1a8b pbrook
                          /* H bit allows addressing to 2-byte boundaries.  */
2898 4b0f1a8b pbrook
                          address += 2;
2899 4b0f1a8b pbrook
2900 4b0f1a8b pbrook
                        info->print_address_func (address, info);
2901 4b0f1a8b pbrook
                      }
2902 4b0f1a8b pbrook
                      break;
2903 4b0f1a8b pbrook
2904 4b0f1a8b pbrook
                    case 'C':
2905 4b0f1a8b pbrook
                      func (stream, "_");
2906 4b0f1a8b pbrook
                      if (given & 0x80000)
2907 4b0f1a8b pbrook
                        func (stream, "f");
2908 4b0f1a8b pbrook
                      if (given & 0x40000)
2909 4b0f1a8b pbrook
                        func (stream, "s");
2910 4b0f1a8b pbrook
                      if (given & 0x20000)
2911 4b0f1a8b pbrook
                        func (stream, "x");
2912 4b0f1a8b pbrook
                      if (given & 0x10000)
2913 4b0f1a8b pbrook
                        func (stream, "c");
2914 4b0f1a8b pbrook
                      break;
2915 4b0f1a8b pbrook
2916 4b0f1a8b pbrook
                    case 'U':
2917 4b0f1a8b pbrook
                      switch (given & 0xf)
2918 4b0f1a8b pbrook
                        {
2919 4b0f1a8b pbrook
                        case 0xf: func(stream, "sy"); break;
2920 4b0f1a8b pbrook
                        case 0x7: func(stream, "un"); break;
2921 4b0f1a8b pbrook
                        case 0xe: func(stream, "st"); break;
2922 4b0f1a8b pbrook
                        case 0x6: func(stream, "unst"); break;
2923 4b0f1a8b pbrook
                        default:
2924 4b0f1a8b pbrook
                          func(stream, "#%d", (int)given & 0xf);
2925 4b0f1a8b pbrook
                          break;
2926 4b0f1a8b pbrook
                        }
2927 4b0f1a8b pbrook
                      break;
2928 4b0f1a8b pbrook
2929 4b0f1a8b pbrook
                    case '0': case '1': case '2': case '3': case '4':
2930 4b0f1a8b pbrook
                    case '5': case '6': case '7': case '8': case '9':
2931 4b0f1a8b pbrook
                      {
2932 4b0f1a8b pbrook
                        int width;
2933 4b0f1a8b pbrook
                        unsigned long value;
2934 4b0f1a8b pbrook
2935 4b0f1a8b pbrook
                        c = arm_decode_bitfield (c, given, &value, &width);
2936 4b0f1a8b pbrook
2937 4b0f1a8b pbrook
                        switch (*c)
2938 4b0f1a8b pbrook
                          {
2939 4b0f1a8b pbrook
                          case 'r':
2940 4b0f1a8b pbrook
                            func (stream, "%s", arm_regnames[value]);
2941 4b0f1a8b pbrook
                            break;
2942 4b0f1a8b pbrook
                          case 'd':
2943 4b0f1a8b pbrook
                            func (stream, "%ld", value);
2944 4b0f1a8b pbrook
                            break;
2945 4b0f1a8b pbrook
                          case 'b':
2946 4b0f1a8b pbrook
                            func (stream, "%ld", value * 8);
2947 4b0f1a8b pbrook
                            break;
2948 4b0f1a8b pbrook
                          case 'W':
2949 4b0f1a8b pbrook
                            func (stream, "%ld", value + 1);
2950 4b0f1a8b pbrook
                            break;
2951 4b0f1a8b pbrook
                          case 'x':
2952 4b0f1a8b pbrook
                            func (stream, "0x%08lx", value);
2953 4b0f1a8b pbrook
2954 4b0f1a8b pbrook
                            /* Some SWI instructions have special
2955 4b0f1a8b pbrook
                               meanings.  */
2956 4b0f1a8b pbrook
                            if ((given & 0x0fffffff) == 0x0FF00000)
2957 4b0f1a8b pbrook
                              func (stream, "\t; IMB");
2958 4b0f1a8b pbrook
                            else if ((given & 0x0fffffff) == 0x0FF00001)
2959 4b0f1a8b pbrook
                              func (stream, "\t; IMBRange");
2960 4b0f1a8b pbrook
                            break;
2961 4b0f1a8b pbrook
                          case 'X':
2962 4b0f1a8b pbrook
                            func (stream, "%01lx", value & 0xf);
2963 4b0f1a8b pbrook
                            break;
2964 4b0f1a8b pbrook
                          case '`':
2965 4b0f1a8b pbrook
                            c++;
2966 4b0f1a8b pbrook
                            if (value == 0)
2967 4b0f1a8b pbrook
                              func (stream, "%c", *c);
2968 4b0f1a8b pbrook
                            break;
2969 4b0f1a8b pbrook
                          case '\'':
2970 4b0f1a8b pbrook
                            c++;
2971 4b0f1a8b pbrook
                            if (value == ((1ul << width) - 1))
2972 4b0f1a8b pbrook
                              func (stream, "%c", *c);
2973 4b0f1a8b pbrook
                            break;
2974 4b0f1a8b pbrook
                          case '?':
2975 4b0f1a8b pbrook
                            func (stream, "%c", c[(1 << width) - (int)value]);
2976 4b0f1a8b pbrook
                            c += 1 << width;
2977 4b0f1a8b pbrook
                            break;
2978 4b0f1a8b pbrook
                          default:
2979 4b0f1a8b pbrook
                            abort ();
2980 4b0f1a8b pbrook
                          }
2981 4b0f1a8b pbrook
                        break;
2982 4b0f1a8b pbrook
2983 4b0f1a8b pbrook
                      case 'e':
2984 4b0f1a8b pbrook
                        {
2985 4b0f1a8b pbrook
                          int imm;
2986 4b0f1a8b pbrook
2987 4b0f1a8b pbrook
                          imm = (given & 0xf) | ((given & 0xfff00) >> 4);
2988 4b0f1a8b pbrook
                          func (stream, "%d", imm);
2989 4b0f1a8b pbrook
                        }
2990 4b0f1a8b pbrook
                        break;
2991 4b0f1a8b pbrook
2992 4b0f1a8b pbrook
                      case 'E':
2993 4b0f1a8b pbrook
                        /* LSB and WIDTH fields of BFI or BFC.  The machine-
2994 4b0f1a8b pbrook
                           language instruction encodes LSB and MSB.  */
2995 4b0f1a8b pbrook
                        {
2996 4b0f1a8b pbrook
                          long msb = (given & 0x001f0000) >> 16;
2997 4b0f1a8b pbrook
                          long lsb = (given & 0x00000f80) >> 7;
2998 4b0f1a8b pbrook
2999 4b0f1a8b pbrook
                          long width = msb - lsb + 1;
3000 4b0f1a8b pbrook
                          if (width > 0)
3001 4b0f1a8b pbrook
                            func (stream, "#%lu, #%lu", lsb, width);
3002 4b0f1a8b pbrook
                          else
3003 4b0f1a8b pbrook
                            func (stream, "(invalid: %lu:%lu)", lsb, msb);
3004 4b0f1a8b pbrook
                        }
3005 4b0f1a8b pbrook
                        break;
3006 4b0f1a8b pbrook
3007 4b0f1a8b pbrook
                      case 'V':
3008 4b0f1a8b pbrook
                        /* 16-bit unsigned immediate from a MOVT or MOVW
3009 4b0f1a8b pbrook
                           instruction, encoded in bits 0:11 and 15:19.  */
3010 4b0f1a8b pbrook
                        {
3011 4b0f1a8b pbrook
                          long hi = (given & 0x000f0000) >> 4;
3012 4b0f1a8b pbrook
                          long lo = (given & 0x00000fff);
3013 4b0f1a8b pbrook
                          long imm16 = hi | lo;
3014 4b0f1a8b pbrook
                          func (stream, "#%lu\t; 0x%lx", imm16, imm16);
3015 4b0f1a8b pbrook
                        }
3016 4b0f1a8b pbrook
                        break;
3017 4b0f1a8b pbrook
3018 4b0f1a8b pbrook
                      default:
3019 4b0f1a8b pbrook
                        abort ();
3020 4b0f1a8b pbrook
                      }
3021 4b0f1a8b pbrook
                    }
3022 4b0f1a8b pbrook
                }
3023 4b0f1a8b pbrook
              else
3024 4b0f1a8b pbrook
                func (stream, "%c", *c);
3025 4b0f1a8b pbrook
            }
3026 4b0f1a8b pbrook
          return;
3027 4b0f1a8b pbrook
        }
3028 4b0f1a8b pbrook
    }
3029 4b0f1a8b pbrook
  abort ();
3030 4b0f1a8b pbrook
}
3031 4b0f1a8b pbrook
3032 4b0f1a8b pbrook
/* Print one 16-bit Thumb instruction from PC on INFO->STREAM.  */
3033 4b0f1a8b pbrook
3034 4b0f1a8b pbrook
static void
3035 4b0f1a8b pbrook
print_insn_thumb16 (bfd_vma pc, struct disassemble_info *info, long given)
3036 4b0f1a8b pbrook
{
3037 4b0f1a8b pbrook
  const struct opcode16 *insn;
3038 4b0f1a8b pbrook
  void *stream = info->stream;
3039 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
3040 4b0f1a8b pbrook
3041 4b0f1a8b pbrook
  for (insn = thumb_opcodes; insn->assembler; insn++)
3042 4b0f1a8b pbrook
    if ((given & insn->mask) == insn->value)
3043 4b0f1a8b pbrook
      {
3044 4b0f1a8b pbrook
        const char *c = insn->assembler;
3045 4b0f1a8b pbrook
        for (; *c; c++)
3046 4b0f1a8b pbrook
          {
3047 4b0f1a8b pbrook
            int domaskpc = 0;
3048 4b0f1a8b pbrook
            int domasklr = 0;
3049 4b0f1a8b pbrook
3050 4b0f1a8b pbrook
            if (*c != '%')
3051 4b0f1a8b pbrook
              {
3052 4b0f1a8b pbrook
                func (stream, "%c", *c);
3053 4b0f1a8b pbrook
                continue;
3054 4b0f1a8b pbrook
              }
3055 4b0f1a8b pbrook
3056 4b0f1a8b pbrook
            switch (*++c)
3057 4b0f1a8b pbrook
              {
3058 4b0f1a8b pbrook
              case '%':
3059 4b0f1a8b pbrook
                func (stream, "%%");
3060 4b0f1a8b pbrook
                break;
3061 4b0f1a8b pbrook
3062 4b0f1a8b pbrook
              case 'c':
3063 4b0f1a8b pbrook
                if (ifthen_state)
3064 4b0f1a8b pbrook
                  func (stream, "%s", arm_conditional[IFTHEN_COND]);
3065 4b0f1a8b pbrook
                break;
3066 4b0f1a8b pbrook
3067 4b0f1a8b pbrook
              case 'C':
3068 4b0f1a8b pbrook
                if (ifthen_state)
3069 4b0f1a8b pbrook
                  func (stream, "%s", arm_conditional[IFTHEN_COND]);
3070 4b0f1a8b pbrook
                else
3071 4b0f1a8b pbrook
                  func (stream, "s");
3072 4b0f1a8b pbrook
                break;
3073 4b0f1a8b pbrook
3074 4b0f1a8b pbrook
              case 'I':
3075 4b0f1a8b pbrook
                {
3076 4b0f1a8b pbrook
                  unsigned int tmp;
3077 4b0f1a8b pbrook
3078 4b0f1a8b pbrook
                  ifthen_next_state = given & 0xff;
3079 4b0f1a8b pbrook
                  for (tmp = given << 1; tmp & 0xf; tmp <<= 1)
3080 4b0f1a8b pbrook
                    func (stream, ((given ^ tmp) & 0x10) ? "e" : "t");
3081 4b0f1a8b pbrook
                  func (stream, "\t%s", arm_conditional[(given >> 4) & 0xf]);
3082 4b0f1a8b pbrook
                }
3083 4b0f1a8b pbrook
                break;
3084 4b0f1a8b pbrook
3085 4b0f1a8b pbrook
              case 'x':
3086 4b0f1a8b pbrook
                if (ifthen_next_state)
3087 4b0f1a8b pbrook
                  func (stream, "\t; unpredictable branch in IT block\n");
3088 4b0f1a8b pbrook
                break;
3089 4b0f1a8b pbrook
3090 4b0f1a8b pbrook
              case 'X':
3091 4b0f1a8b pbrook
                if (ifthen_state)
3092 4b0f1a8b pbrook
                  func (stream, "\t; unpredictable <IT:%s>",
3093 4b0f1a8b pbrook
                        arm_conditional[IFTHEN_COND]);
3094 4b0f1a8b pbrook
                break;
3095 4b0f1a8b pbrook
3096 4b0f1a8b pbrook
              case 'S':
3097 4b0f1a8b pbrook
                {
3098 4b0f1a8b pbrook
                  long reg;
3099 4b0f1a8b pbrook
3100 4b0f1a8b pbrook
                  reg = (given >> 3) & 0x7;
3101 4b0f1a8b pbrook
                  if (given & (1 << 6))
3102 4b0f1a8b pbrook
                    reg += 8;
3103 4b0f1a8b pbrook
3104 4b0f1a8b pbrook
                  func (stream, "%s", arm_regnames[reg]);
3105 4b0f1a8b pbrook
                }
3106 4b0f1a8b pbrook
                break;
3107 4b0f1a8b pbrook
3108 4b0f1a8b pbrook
              case 'D':
3109 4b0f1a8b pbrook
                {
3110 4b0f1a8b pbrook
                  long reg;
3111 4b0f1a8b pbrook
3112 4b0f1a8b pbrook
                  reg = given & 0x7;
3113 4b0f1a8b pbrook
                  if (given & (1 << 7))
3114 4b0f1a8b pbrook
                    reg += 8;
3115 4b0f1a8b pbrook
3116 4b0f1a8b pbrook
                  func (stream, "%s", arm_regnames[reg]);
3117 4b0f1a8b pbrook
                }
3118 4b0f1a8b pbrook
                break;
3119 4b0f1a8b pbrook
3120 4b0f1a8b pbrook
              case 'N':
3121 4b0f1a8b pbrook
                if (given & (1 << 8))
3122 4b0f1a8b pbrook
                  domasklr = 1;
3123 4b0f1a8b pbrook
                /* Fall through.  */
3124 4b0f1a8b pbrook
              case 'O':
3125 4b0f1a8b pbrook
                if (*c == 'O' && (given & (1 << 8)))
3126 4b0f1a8b pbrook
                  domaskpc = 1;
3127 4b0f1a8b pbrook
                /* Fall through.  */
3128 4b0f1a8b pbrook
              case 'M':
3129 4b0f1a8b pbrook
                {
3130 4b0f1a8b pbrook
                  int started = 0;
3131 4b0f1a8b pbrook
                  int reg;
3132 4b0f1a8b pbrook
3133 4b0f1a8b pbrook
                  func (stream, "{");
3134 4b0f1a8b pbrook
3135 4b0f1a8b pbrook
                  /* It would be nice if we could spot
3136 4b0f1a8b pbrook
                     ranges, and generate the rS-rE format: */
3137 4b0f1a8b pbrook
                  for (reg = 0; (reg < 8); reg++)
3138 4b0f1a8b pbrook
                    if ((given & (1 << reg)) != 0)
3139 4b0f1a8b pbrook
                      {
3140 4b0f1a8b pbrook
                        if (started)
3141 4b0f1a8b pbrook
                          func (stream, ", ");
3142 4b0f1a8b pbrook
                        started = 1;
3143 4b0f1a8b pbrook
                        func (stream, "%s", arm_regnames[reg]);
3144 4b0f1a8b pbrook
                      }
3145 4b0f1a8b pbrook
3146 4b0f1a8b pbrook
                  if (domasklr)
3147 4b0f1a8b pbrook
                    {
3148 4b0f1a8b pbrook
                      if (started)
3149 4b0f1a8b pbrook
                        func (stream, ", ");
3150 4b0f1a8b pbrook
                      started = 1;
3151 07b1a9da Stefan Weil
                      func (stream, "%s", arm_regnames[14] /* "lr" */);
3152 4b0f1a8b pbrook
                    }
3153 4b0f1a8b pbrook
3154 4b0f1a8b pbrook
                  if (domaskpc)
3155 4b0f1a8b pbrook
                    {
3156 4b0f1a8b pbrook
                      if (started)
3157 4b0f1a8b pbrook
                        func (stream, ", ");
3158 07b1a9da Stefan Weil
                      func (stream, "%s", arm_regnames[15] /* "pc" */);
3159 4b0f1a8b pbrook
                    }
3160 aa0aa4fa bellard
3161 4b0f1a8b pbrook
                  func (stream, "}");
3162 4b0f1a8b pbrook
                }
3163 4b0f1a8b pbrook
                break;
3164 aa0aa4fa bellard
3165 4b0f1a8b pbrook
              case 'b':
3166 4b0f1a8b pbrook
                /* Print ARM V6T2 CZB address: pc+4+6 bits.  */
3167 4b0f1a8b pbrook
                {
3168 4b0f1a8b pbrook
                  bfd_vma address = (pc + 4
3169 4b0f1a8b pbrook
                                     + ((given & 0x00f8) >> 2)
3170 4b0f1a8b pbrook
                                     + ((given & 0x0200) >> 3));
3171 4b0f1a8b pbrook
                  info->print_address_func (address, info);
3172 4b0f1a8b pbrook
                }
3173 4b0f1a8b pbrook
                break;
3174 aa0aa4fa bellard
3175 4b0f1a8b pbrook
              case 's':
3176 4b0f1a8b pbrook
                /* Right shift immediate -- bits 6..10; 1-31 print
3177 4b0f1a8b pbrook
                   as themselves, 0 prints as 32.  */
3178 4b0f1a8b pbrook
                {
3179 4b0f1a8b pbrook
                  long imm = (given & 0x07c0) >> 6;
3180 4b0f1a8b pbrook
                  if (imm == 0)
3181 4b0f1a8b pbrook
                    imm = 32;
3182 4b0f1a8b pbrook
                  func (stream, "#%ld", imm);
3183 4b0f1a8b pbrook
                }
3184 4b0f1a8b pbrook
                break;
3185 aa0aa4fa bellard
3186 4b0f1a8b pbrook
              case '0': case '1': case '2': case '3': case '4':
3187 4b0f1a8b pbrook
              case '5': case '6': case '7': case '8': case '9':
3188 4b0f1a8b pbrook
                {
3189 4b0f1a8b pbrook
                  int bitstart = *c++ - '0';
3190 4b0f1a8b pbrook
                  int bitend = 0;
3191 3b46e624 ths
3192 4b0f1a8b pbrook
                  while (*c >= '0' && *c <= '9')
3193 4b0f1a8b pbrook
                    bitstart = (bitstart * 10) + *c++ - '0';
3194 aa0aa4fa bellard
3195 4b0f1a8b pbrook
                  switch (*c)
3196 4b0f1a8b pbrook
                    {
3197 4b0f1a8b pbrook
                    case '-':
3198 4b0f1a8b pbrook
                      {
3199 4b0f1a8b pbrook
                        long reg;
3200 4b0f1a8b pbrook
3201 4b0f1a8b pbrook
                        c++;
3202 4b0f1a8b pbrook
                        while (*c >= '0' && *c <= '9')
3203 4b0f1a8b pbrook
                          bitend = (bitend * 10) + *c++ - '0';
3204 4b0f1a8b pbrook
                        if (!bitend)
3205 4b0f1a8b pbrook
                          abort ();
3206 4b0f1a8b pbrook
                        reg = given >> bitstart;
3207 4b0f1a8b pbrook
                        reg &= (2 << (bitend - bitstart)) - 1;
3208 4b0f1a8b pbrook
                        switch (*c)
3209 4b0f1a8b pbrook
                          {
3210 4b0f1a8b pbrook
                          case 'r':
3211 4b0f1a8b pbrook
                            func (stream, "%s", arm_regnames[reg]);
3212 4b0f1a8b pbrook
                            break;
3213 4b0f1a8b pbrook
3214 4b0f1a8b pbrook
                          case 'd':
3215 4b0f1a8b pbrook
                            func (stream, "%ld", reg);
3216 4b0f1a8b pbrook
                            break;
3217 4b0f1a8b pbrook
3218 4b0f1a8b pbrook
                          case 'H':
3219 4b0f1a8b pbrook
                            func (stream, "%ld", reg << 1);
3220 4b0f1a8b pbrook
                            break;
3221 4b0f1a8b pbrook
3222 4b0f1a8b pbrook
                          case 'W':
3223 4b0f1a8b pbrook
                            func (stream, "%ld", reg << 2);
3224 4b0f1a8b pbrook
                            break;
3225 4b0f1a8b pbrook
3226 4b0f1a8b pbrook
                          case 'a':
3227 4b0f1a8b pbrook
                            /* PC-relative address -- the bottom two
3228 4b0f1a8b pbrook
                               bits of the address are dropped
3229 4b0f1a8b pbrook
                               before the calculation.  */
3230 4b0f1a8b pbrook
                            info->print_address_func
3231 4b0f1a8b pbrook
                              (((pc + 4) & ~3) + (reg << 2), info);
3232 4b0f1a8b pbrook
                            break;
3233 4b0f1a8b pbrook
3234 4b0f1a8b pbrook
                          case 'x':
3235 4b0f1a8b pbrook
                            func (stream, "0x%04lx", reg);
3236 4b0f1a8b pbrook
                            break;
3237 4b0f1a8b pbrook
3238 4b0f1a8b pbrook
                          case 'B':
3239 4b0f1a8b pbrook
                            reg = ((reg ^ (1 << bitend)) - (1 << bitend));
3240 4b0f1a8b pbrook
                            info->print_address_func (reg * 2 + pc + 4, info);
3241 4b0f1a8b pbrook
                            break;
3242 4b0f1a8b pbrook
3243 4b0f1a8b pbrook
                          case 'c':
3244 4b0f1a8b pbrook
                            func (stream, "%s", arm_conditional [reg]);
3245 4b0f1a8b pbrook
                            break;
3246 4b0f1a8b pbrook
3247 4b0f1a8b pbrook
                          default:
3248 4b0f1a8b pbrook
                            abort ();
3249 4b0f1a8b pbrook
                          }
3250 4b0f1a8b pbrook
                      }
3251 4b0f1a8b pbrook
                      break;
3252 4b0f1a8b pbrook
3253 4b0f1a8b pbrook
                    case '\'':
3254 4b0f1a8b pbrook
                      c++;
3255 4b0f1a8b pbrook
                      if ((given & (1 << bitstart)) != 0)
3256 4b0f1a8b pbrook
                        func (stream, "%c", *c);
3257 4b0f1a8b pbrook
                      break;
3258 4b0f1a8b pbrook
3259 4b0f1a8b pbrook
                    case '?':
3260 4b0f1a8b pbrook
                      ++c;
3261 4b0f1a8b pbrook
                      if ((given & (1 << bitstart)) != 0)
3262 4b0f1a8b pbrook
                        func (stream, "%c", *c++);
3263 4b0f1a8b pbrook
                      else
3264 4b0f1a8b pbrook
                        func (stream, "%c", *++c);
3265 4b0f1a8b pbrook
                      break;
3266 4b0f1a8b pbrook
3267 4b0f1a8b pbrook
                    default:
3268 4b0f1a8b pbrook
                      abort ();
3269 4b0f1a8b pbrook
                    }
3270 4b0f1a8b pbrook
                }
3271 4b0f1a8b pbrook
                break;
3272 4b0f1a8b pbrook
3273 4b0f1a8b pbrook
              default:
3274 4b0f1a8b pbrook
                abort ();
3275 4b0f1a8b pbrook
              }
3276 4b0f1a8b pbrook
          }
3277 4b0f1a8b pbrook
        return;
3278 4b0f1a8b pbrook
      }
3279 aa0aa4fa bellard
3280 aa0aa4fa bellard
  /* No match.  */
3281 aa0aa4fa bellard
  abort ();
3282 aa0aa4fa bellard
}
3283 aa0aa4fa bellard
3284 4b0f1a8b pbrook
/* Return the name of an V7M special register.  */
3285 4b0f1a8b pbrook
static const char *
3286 4b0f1a8b pbrook
psr_name (int regno)
3287 4b0f1a8b pbrook
{
3288 4b0f1a8b pbrook
  switch (regno)
3289 4b0f1a8b pbrook
    {
3290 4b0f1a8b pbrook
    case 0: return "APSR";
3291 4b0f1a8b pbrook
    case 1: return "IAPSR";
3292 4b0f1a8b pbrook
    case 2: return "EAPSR";
3293 4b0f1a8b pbrook
    case 3: return "PSR";
3294 4b0f1a8b pbrook
    case 5: return "IPSR";
3295 4b0f1a8b pbrook
    case 6: return "EPSR";
3296 4b0f1a8b pbrook
    case 7: return "IEPSR";
3297 4b0f1a8b pbrook
    case 8: return "MSP";
3298 4b0f1a8b pbrook
    case 9: return "PSP";
3299 4b0f1a8b pbrook
    case 16: return "PRIMASK";
3300 4b0f1a8b pbrook
    case 17: return "BASEPRI";
3301 4b0f1a8b pbrook
    case 18: return "BASEPRI_MASK";
3302 4b0f1a8b pbrook
    case 19: return "FAULTMASK";
3303 4b0f1a8b pbrook
    case 20: return "CONTROL";
3304 4b0f1a8b pbrook
    default: return "<unknown>";
3305 4b0f1a8b pbrook
    }
3306 4b0f1a8b pbrook
}
3307 4b0f1a8b pbrook
3308 4b0f1a8b pbrook
/* Print one 32-bit Thumb instruction from PC on INFO->STREAM.  */
3309 aa0aa4fa bellard
3310 4b0f1a8b pbrook
static void
3311 4b0f1a8b pbrook
print_insn_thumb32 (bfd_vma pc, struct disassemble_info *info, long given)
3312 aa0aa4fa bellard
{
3313 4b0f1a8b pbrook
  const struct opcode32 *insn;
3314 4b0f1a8b pbrook
  void *stream = info->stream;
3315 6e2d864e Stefan Weil
  fprintf_function func = info->fprintf_func;
3316 3b46e624 ths
3317 47cbc7aa Juan Quintela
  if (print_insn_coprocessor (pc, info, given, true))
3318 4b0f1a8b pbrook
    return;
3319 5fafdf24 ths
3320 47cbc7aa Juan Quintela
  if (print_insn_neon (info, given, true))
3321 4b0f1a8b pbrook
    return;
3322 aa0aa4fa bellard
3323 4b0f1a8b pbrook
  for (insn = thumb32_opcodes; insn->assembler; insn++)
3324 4b0f1a8b pbrook
    if ((given & insn->mask) == insn->value)
3325 4b0f1a8b pbrook
      {
3326 4b0f1a8b pbrook
        const char *c = insn->assembler;
3327 4b0f1a8b pbrook
        for (; *c; c++)
3328 aa0aa4fa bellard
          {
3329 4b0f1a8b pbrook
            if (*c != '%')
3330 4b0f1a8b pbrook
              {
3331 4b0f1a8b pbrook
                func (stream, "%c", *c);
3332 4b0f1a8b pbrook
                continue;
3333 4b0f1a8b pbrook
              }
3334 4b0f1a8b pbrook
3335 4b0f1a8b pbrook
            switch (*++c)
3336 4b0f1a8b pbrook
              {
3337 4b0f1a8b pbrook
              case '%':
3338 4b0f1a8b pbrook
                func (stream, "%%");
3339 4b0f1a8b pbrook
                break;
3340 4b0f1a8b pbrook
3341 4b0f1a8b pbrook
              case 'c':
3342 4b0f1a8b pbrook
                if (ifthen_state)
3343 4b0f1a8b pbrook
                  func (stream, "%s", arm_conditional[IFTHEN_COND]);
3344 4b0f1a8b pbrook
                break;
3345 4b0f1a8b pbrook
3346 4b0f1a8b pbrook
              case 'x':
3347 4b0f1a8b pbrook
                if (ifthen_next_state)
3348 4b0f1a8b pbrook
                  func (stream, "\t; unpredictable branch in IT block\n");
3349 4b0f1a8b pbrook
                break;
3350 4b0f1a8b pbrook
3351 4b0f1a8b pbrook
              case 'X':
3352 4b0f1a8b pbrook
                if (ifthen_state)
3353 4b0f1a8b pbrook
                  func (stream, "\t; unpredictable <IT:%s>",
3354 4b0f1a8b pbrook
                        arm_conditional[IFTHEN_COND]);
3355 4b0f1a8b pbrook
                break;
3356 4b0f1a8b pbrook
3357 4b0f1a8b pbrook
              case 'I':
3358 4b0f1a8b pbrook
                {
3359 4b0f1a8b pbrook
                  unsigned int imm12 = 0;
3360 4b0f1a8b pbrook
                  imm12 |= (given & 0x000000ffu);
3361 4b0f1a8b pbrook
                  imm12 |= (given & 0x00007000u) >> 4;
3362 4b0f1a8b pbrook
                  imm12 |= (given & 0x04000000u) >> 15;
3363 4b0f1a8b pbrook
                  func (stream, "#%u\t; 0x%x", imm12, imm12);
3364 4b0f1a8b pbrook
                }
3365 4b0f1a8b pbrook
                break;
3366 3b46e624 ths
3367 4b0f1a8b pbrook
              case 'M':
3368 4b0f1a8b pbrook
                {
3369 4b0f1a8b pbrook
                  unsigned int bits = 0, imm, imm8, mod;
3370 4b0f1a8b pbrook
                  bits |= (given & 0x000000ffu);
3371 4b0f1a8b pbrook
                  bits |= (given & 0x00007000u) >> 4;
3372 4b0f1a8b pbrook
                  bits |= (given & 0x04000000u) >> 15;
3373 4b0f1a8b pbrook
                  imm8 = (bits & 0x0ff);
3374 4b0f1a8b pbrook
                  mod = (bits & 0xf00) >> 8;
3375 4b0f1a8b pbrook
                  switch (mod)
3376 4b0f1a8b pbrook
                    {
3377 4b0f1a8b pbrook
                    case 0: imm = imm8; break;
3378 4b0f1a8b pbrook
                    case 1: imm = ((imm8<<16) | imm8); break;
3379 4b0f1a8b pbrook
                    case 2: imm = ((imm8<<24) | (imm8 << 8)); break;
3380 4b0f1a8b pbrook
                    case 3: imm = ((imm8<<24) | (imm8 << 16) | (imm8 << 8) | imm8); break;
3381 4b0f1a8b pbrook
                    default:
3382 4b0f1a8b pbrook
                      mod  = (bits & 0xf80) >> 7;
3383 4b0f1a8b pbrook
                      imm8 = (bits & 0x07f) | 0x80;
3384 4b0f1a8b pbrook
                      imm  = (((imm8 << (32 - mod)) | (imm8 >> mod)) & 0xffffffff);
3385 4b0f1a8b pbrook
                    }
3386 4b0f1a8b pbrook
                  func (stream, "#%u\t; 0x%x", imm, imm);
3387 4b0f1a8b pbrook
                }
3388 4b0f1a8b pbrook
                break;
3389 4b0f1a8b pbrook
3390 4b0f1a8b pbrook
              case 'J':
3391 4b0f1a8b pbrook
                {
3392 4b0f1a8b pbrook
                  unsigned int imm = 0;
3393 4b0f1a8b pbrook
                  imm |= (given & 0x000000ffu);
3394 4b0f1a8b pbrook
                  imm |= (given & 0x00007000u) >> 4;
3395 4b0f1a8b pbrook
                  imm |= (given & 0x04000000u) >> 15;
3396 4b0f1a8b pbrook
                  imm |= (given & 0x000f0000u) >> 4;
3397 4b0f1a8b pbrook
                  func (stream, "#%u\t; 0x%x", imm, imm);
3398 4b0f1a8b pbrook
                }
3399 4b0f1a8b pbrook
                break;
3400 4b0f1a8b pbrook
3401 4b0f1a8b pbrook
              case 'K':
3402 4b0f1a8b pbrook
                {
3403 4b0f1a8b pbrook
                  unsigned int imm = 0;
3404 4b0f1a8b pbrook
                  imm |= (given & 0x000f0000u) >> 16;
3405 4b0f1a8b pbrook
                  imm |= (given & 0x00000ff0u) >> 0;
3406 4b0f1a8b pbrook
                  imm |= (given & 0x0000000fu) << 12;
3407 4b0f1a8b pbrook
                  func (stream, "#%u\t; 0x%x", imm, imm);
3408 4b0f1a8b pbrook
                }
3409 4b0f1a8b pbrook
                break;
3410 4b0f1a8b pbrook
3411 4b0f1a8b pbrook
              case 'S':
3412 4b0f1a8b pbrook
                {
3413 4b0f1a8b pbrook
                  unsigned int reg = (given & 0x0000000fu);
3414 4b0f1a8b pbrook
                  unsigned int stp = (given & 0x00000030u) >> 4;
3415 4b0f1a8b pbrook
                  unsigned int imm = 0;
3416 4b0f1a8b pbrook
                  imm |= (given & 0x000000c0u) >> 6;
3417 4b0f1a8b pbrook
                  imm |= (given & 0x00007000u) >> 10;
3418 4b0f1a8b pbrook
3419 4b0f1a8b pbrook
                  func (stream, "%s", arm_regnames[reg]);
3420 4b0f1a8b pbrook
                  switch (stp)
3421 4b0f1a8b pbrook
                    {
3422 4b0f1a8b pbrook
                    case 0:
3423 4b0f1a8b pbrook
                      if (imm > 0)
3424 4b0f1a8b pbrook
                        func (stream, ", lsl #%u", imm);
3425 4b0f1a8b pbrook
                      break;
3426 4b0f1a8b pbrook
3427 4b0f1a8b pbrook
                    case 1:
3428 4b0f1a8b pbrook
                      if (imm == 0)
3429 4b0f1a8b pbrook
                        imm = 32;
3430 4b0f1a8b pbrook
                      func (stream, ", lsr #%u", imm);
3431 4b0f1a8b pbrook
                      break;
3432 4b0f1a8b pbrook
3433 4b0f1a8b pbrook
                    case 2:
3434 4b0f1a8b pbrook
                      if (imm == 0)
3435 4b0f1a8b pbrook
                        imm = 32;
3436 4b0f1a8b pbrook
                      func (stream, ", asr #%u", imm);
3437 4b0f1a8b pbrook
                      break;
3438 4b0f1a8b pbrook
3439 4b0f1a8b pbrook
                    case 3:
3440 4b0f1a8b pbrook
                      if (imm == 0)
3441 4b0f1a8b pbrook
                        func (stream, ", rrx");
3442 4b0f1a8b pbrook
                      else
3443 4b0f1a8b pbrook
                        func (stream, ", ror #%u", imm);
3444 4b0f1a8b pbrook
                    }
3445 4b0f1a8b pbrook
                }
3446 4b0f1a8b pbrook
                break;
3447 4b0f1a8b pbrook
3448 4b0f1a8b pbrook
              case 'a':
3449 4b0f1a8b pbrook
                {
3450 4b0f1a8b pbrook
                  unsigned int Rn  = (given & 0x000f0000) >> 16;
3451 4b0f1a8b pbrook
                  unsigned int U   = (given & 0x00800000) >> 23;
3452 4b0f1a8b pbrook
                  unsigned int op  = (given & 0x00000f00) >> 8;
3453 4b0f1a8b pbrook
                  unsigned int i12 = (given & 0x00000fff);
3454 4b0f1a8b pbrook
                  unsigned int i8  = (given & 0x000000ff);
3455 47cbc7aa Juan Quintela
                  bfd_boolean writeback = false, postind = false;
3456 4b0f1a8b pbrook
                  int offset = 0;
3457 4b0f1a8b pbrook
3458 4b0f1a8b pbrook
                  func (stream, "[%s", arm_regnames[Rn]);
3459 4b0f1a8b pbrook
                  if (U) /* 12-bit positive immediate offset */
3460 4b0f1a8b pbrook
                    offset = i12;
3461 4b0f1a8b pbrook
                  else if (Rn == 15) /* 12-bit negative immediate offset */
3462 4b0f1a8b pbrook
                    offset = -(int)i12;
3463 4b0f1a8b pbrook
                  else if (op == 0x0) /* shifted register offset */
3464 4b0f1a8b pbrook
                    {
3465 4b0f1a8b pbrook
                      unsigned int Rm = (i8 & 0x0f);
3466 4b0f1a8b pbrook
                      unsigned int sh = (i8 & 0x30) >> 4;
3467 4b0f1a8b pbrook
                      func (stream, ", %s", arm_regnames[Rm]);
3468 4b0f1a8b pbrook
                      if (sh)
3469 4b0f1a8b pbrook
                        func (stream, ", lsl #%u", sh);
3470 4b0f1a8b pbrook
                      func (stream, "]");
3471 4b0f1a8b pbrook
                      break;
3472 4b0f1a8b pbrook
                    }
3473 4b0f1a8b pbrook
                  else switch (op)
3474 4b0f1a8b pbrook
                    {
3475 4b0f1a8b pbrook
                    case 0xE:  /* 8-bit positive immediate offset */
3476 4b0f1a8b pbrook
                      offset = i8;
3477 4b0f1a8b pbrook
                      break;
3478 4b0f1a8b pbrook
3479 4b0f1a8b pbrook
                    case 0xC:  /* 8-bit negative immediate offset */
3480 4b0f1a8b pbrook
                      offset = -i8;
3481 4b0f1a8b pbrook
                      break;
3482 4b0f1a8b pbrook
3483 4b0f1a8b pbrook
                    case 0xF:  /* 8-bit + preindex with wb */
3484 4b0f1a8b pbrook
                      offset = i8;
3485 47cbc7aa Juan Quintela
                      writeback = true;
3486 4b0f1a8b pbrook
                      break;
3487 4b0f1a8b pbrook
3488 4b0f1a8b pbrook
                    case 0xD:  /* 8-bit - preindex with wb */
3489 4b0f1a8b pbrook
                      offset = -i8;
3490 47cbc7aa Juan Quintela
                      writeback = true;
3491 4b0f1a8b pbrook
                      break;
3492 4b0f1a8b pbrook
3493 4b0f1a8b pbrook
                    case 0xB:  /* 8-bit + postindex */
3494 4b0f1a8b pbrook
                      offset = i8;
3495 47cbc7aa Juan Quintela
                      postind = true;
3496 4b0f1a8b pbrook
                      break;
3497 4b0f1a8b pbrook
3498 4b0f1a8b pbrook
                    case 0x9:  /* 8-bit - postindex */
3499 4b0f1a8b pbrook
                      offset = -i8;
3500 47cbc7aa Juan Quintela
                      postind = true;
3501 4b0f1a8b pbrook
                      break;
3502 4b0f1a8b pbrook
3503 4b0f1a8b pbrook
                    default:
3504 4b0f1a8b pbrook
                      func (stream, ", <undefined>]");
3505 4b0f1a8b pbrook
                      goto skip;
3506 4b0f1a8b pbrook
                    }
3507 4b0f1a8b pbrook
3508 4b0f1a8b pbrook
                  if (postind)
3509 4b0f1a8b pbrook
                    func (stream, "], #%d", offset);
3510 4b0f1a8b pbrook
                  else
3511 4b0f1a8b pbrook
                    {
3512 4b0f1a8b pbrook
                      if (offset)
3513 4b0f1a8b pbrook
                        func (stream, ", #%d", offset);
3514 4b0f1a8b pbrook
                      func (stream, writeback ? "]!" : "]");
3515 4b0f1a8b pbrook
                    }
3516 4b0f1a8b pbrook
3517 4b0f1a8b pbrook
                  if (Rn == 15)
3518 4b0f1a8b pbrook
                    {
3519 4b0f1a8b pbrook
                      func (stream, "\t; ");
3520 4b0f1a8b pbrook
                      info->print_address_func (((pc + 4) & ~3) + offset, info);
3521 4b0f1a8b pbrook
                    }
3522 4b0f1a8b pbrook
                }
3523 4b0f1a8b pbrook
              skip:
3524 4b0f1a8b pbrook
                break;
3525 4b0f1a8b pbrook
3526 4b0f1a8b pbrook
              case 'A':
3527 4b0f1a8b pbrook
                {
3528 4b0f1a8b pbrook
                  unsigned int P   = (given & 0x01000000) >> 24;
3529 4b0f1a8b pbrook
                  unsigned int U   = (given & 0x00800000) >> 23;
3530 4b0f1a8b pbrook
                  unsigned int W   = (given & 0x00400000) >> 21;
3531 4b0f1a8b pbrook
                  unsigned int Rn  = (given & 0x000f0000) >> 16;
3532 4b0f1a8b pbrook
                  unsigned int off = (given & 0x000000ff);
3533 4b0f1a8b pbrook
3534 4b0f1a8b pbrook
                  func (stream, "[%s", arm_regnames[Rn]);
3535 4b0f1a8b pbrook
                  if (P)
3536 4b0f1a8b pbrook
                    {
3537 4b0f1a8b pbrook
                      if (off || !U)
3538 4b0f1a8b pbrook
                        func (stream, ", #%c%u", U ? '+' : '-', off * 4);
3539 4b0f1a8b pbrook
                      func (stream, "]");
3540 4b0f1a8b pbrook
                      if (W)
3541 4b0f1a8b pbrook
                        func (stream, "!");
3542 4b0f1a8b pbrook
                    }
3543 4b0f1a8b pbrook
                  else
3544 4b0f1a8b pbrook
                    {
3545 4b0f1a8b pbrook
                      func (stream, "], ");
3546 4b0f1a8b pbrook
                      if (W)
3547 4b0f1a8b pbrook
                        func (stream, "#%c%u", U ? '+' : '-', off * 4);
3548 4b0f1a8b pbrook
                      else
3549 4b0f1a8b pbrook
                        func (stream, "{%u}", off);
3550 4b0f1a8b pbrook
                    }
3551 4b0f1a8b pbrook
                }
3552 4b0f1a8b pbrook
                break;
3553 4b0f1a8b pbrook
3554 4b0f1a8b pbrook
              case 'w':
3555 4b0f1a8b pbrook
                {
3556 4b0f1a8b pbrook
                  unsigned int Sbit = (given & 0x01000000) >> 24;
3557 4b0f1a8b pbrook
                  unsigned int type = (given & 0x00600000) >> 21;
3558 4b0f1a8b pbrook
                  switch (type)
3559 4b0f1a8b pbrook
                    {
3560 4b0f1a8b pbrook
                    case 0: func (stream, Sbit ? "sb" : "b"); break;
3561 4b0f1a8b pbrook
                    case 1: func (stream, Sbit ? "sh" : "h"); break;
3562 4b0f1a8b pbrook
                    case 2:
3563 4b0f1a8b pbrook
                      if (Sbit)
3564 4b0f1a8b pbrook
                        func (stream, "??");
3565 4b0f1a8b pbrook
                      break;
3566 4b0f1a8b pbrook
                    case 3:
3567 4b0f1a8b pbrook
                      func (stream, "??");
3568 4b0f1a8b pbrook
                      break;
3569 4b0f1a8b pbrook
                    }
3570 4b0f1a8b pbrook
                }
3571 4b0f1a8b pbrook
                break;
3572 4b0f1a8b pbrook
3573 4b0f1a8b pbrook
              case 'm':
3574 4b0f1a8b pbrook
                {
3575 4b0f1a8b pbrook
                  int started = 0;
3576 4b0f1a8b pbrook
                  int reg;
3577 4b0f1a8b pbrook
3578 4b0f1a8b pbrook
                  func (stream, "{");
3579 4b0f1a8b pbrook
                  for (reg = 0; reg < 16; reg++)
3580 4b0f1a8b pbrook
                    if ((given & (1 << reg)) != 0)
3581 4b0f1a8b pbrook
                      {
3582 4b0f1a8b pbrook
                        if (started)
3583 4b0f1a8b pbrook
                          func (stream, ", ");
3584 4b0f1a8b pbrook
                        started = 1;
3585 4b0f1a8b pbrook
                        func (stream, "%s", arm_regnames[reg]);
3586 4b0f1a8b pbrook
                      }
3587 4b0f1a8b pbrook
                  func (stream, "}");
3588 4b0f1a8b pbrook
                }
3589 4b0f1a8b pbrook
                break;
3590 4b0f1a8b pbrook
3591 4b0f1a8b pbrook
              case 'E':
3592 4b0f1a8b pbrook
                {
3593 4b0f1a8b pbrook
                  unsigned int msb = (given & 0x0000001f);
3594 4b0f1a8b pbrook
                  unsigned int lsb = 0;
3595 4b0f1a8b pbrook
                  lsb |= (given & 0x000000c0u) >> 6;
3596 4b0f1a8b pbrook
                  lsb |= (given & 0x00007000u) >> 10;
3597 4b0f1a8b pbrook
                  func (stream, "#%u, #%u", lsb, msb - lsb + 1);
3598 4b0f1a8b pbrook
                }
3599 4b0f1a8b pbrook
                break;
3600 4b0f1a8b pbrook
3601 4b0f1a8b pbrook
              case 'F':
3602 4b0f1a8b pbrook
                {
3603 4b0f1a8b pbrook
                  unsigned int width = (given & 0x0000001f) + 1;
3604 4b0f1a8b pbrook
                  unsigned int lsb = 0;
3605 4b0f1a8b pbrook
                  lsb |= (given & 0x000000c0u) >> 6;
3606 4b0f1a8b pbrook
                  lsb |= (given & 0x00007000u) >> 10;
3607 4b0f1a8b pbrook
                  func (stream, "#%u, #%u", lsb, width);
3608 4b0f1a8b pbrook
                }
3609 4b0f1a8b pbrook
                break;
3610 4b0f1a8b pbrook
3611 4b0f1a8b pbrook
              case 'b':
3612 4b0f1a8b pbrook
                {
3613 4b0f1a8b pbrook
                  unsigned int S = (given & 0x04000000u) >> 26;
3614 4b0f1a8b pbrook
                  unsigned int J1 = (given & 0x00002000u) >> 13;
3615 4b0f1a8b pbrook
                  unsigned int J2 = (given & 0x00000800u) >> 11;
3616 4b0f1a8b pbrook
                  int offset = 0;
3617 4b0f1a8b pbrook
3618 4b0f1a8b pbrook
                  offset |= !S << 20;
3619 4b0f1a8b pbrook
                  offset |= J2 << 19;
3620 4b0f1a8b pbrook
                  offset |= J1 << 18;
3621 4b0f1a8b pbrook
                  offset |= (given & 0x003f0000) >> 4;
3622 4b0f1a8b pbrook
                  offset |= (given & 0x000007ff) << 1;
3623 4b0f1a8b pbrook
                  offset -= (1 << 20);
3624 4b0f1a8b pbrook
3625 4b0f1a8b pbrook
                  info->print_address_func (pc + 4 + offset, info);
3626 4b0f1a8b pbrook
                }
3627 4b0f1a8b pbrook
                break;
3628 4b0f1a8b pbrook
3629 4b0f1a8b pbrook
              case 'B':
3630 4b0f1a8b pbrook
                {
3631 4b0f1a8b pbrook
                  unsigned int S = (given & 0x04000000u) >> 26;
3632 4b0f1a8b pbrook
                  unsigned int I1 = (given & 0x00002000u) >> 13;
3633 4b0f1a8b pbrook
                  unsigned int I2 = (given & 0x00000800u) >> 11;
3634 4b0f1a8b pbrook
                  int offset = 0;
3635 4b0f1a8b pbrook
3636 4b0f1a8b pbrook
                  offset |= !S << 24;
3637 4b0f1a8b pbrook
                  offset |= !(I1 ^ S) << 23;
3638 4b0f1a8b pbrook
                  offset |= !(I2 ^ S) << 22;
3639 4b0f1a8b pbrook
                  offset |= (given & 0x03ff0000u) >> 4;
3640 4b0f1a8b pbrook
                  offset |= (given & 0x000007ffu) << 1;
3641 4b0f1a8b pbrook
                  offset -= (1 << 24);
3642 4b0f1a8b pbrook
                  offset += pc + 4;
3643 4b0f1a8b pbrook
3644 4b0f1a8b pbrook
                  /* BLX target addresses are always word aligned.  */
3645 4b0f1a8b pbrook
                  if ((given & 0x00001000u) == 0)
3646 4b0f1a8b pbrook
                      offset &= ~2u;
3647 4b0f1a8b pbrook
3648 4b0f1a8b pbrook
                  info->print_address_func (offset, info);
3649 4b0f1a8b pbrook
                }
3650 4b0f1a8b pbrook
                break;
3651 4b0f1a8b pbrook
3652 4b0f1a8b pbrook
              case 's':
3653 4b0f1a8b pbrook
                {
3654 4b0f1a8b pbrook
                  unsigned int shift = 0;
3655 4b0f1a8b pbrook
                  shift |= (given & 0x000000c0u) >> 6;
3656 4b0f1a8b pbrook
                  shift |= (given & 0x00007000u) >> 10;
3657 4b0f1a8b pbrook
                  if (given & 0x00200000u)
3658 4b0f1a8b pbrook
                    func (stream, ", asr #%u", shift);
3659 4b0f1a8b pbrook
                  else if (shift)
3660 4b0f1a8b pbrook
                    func (stream, ", lsl #%u", shift);
3661 4b0f1a8b pbrook
                  /* else print nothing - lsl #0 */
3662 4b0f1a8b pbrook
                }
3663 4b0f1a8b pbrook
                break;
3664 4b0f1a8b pbrook
3665 4b0f1a8b pbrook
              case 'R':
3666 4b0f1a8b pbrook
                {
3667 4b0f1a8b pbrook
                  unsigned int rot = (given & 0x00000030) >> 4;
3668 4b0f1a8b pbrook
                  if (rot)
3669 4b0f1a8b pbrook
                    func (stream, ", ror #%u", rot * 8);
3670 4b0f1a8b pbrook
                }
3671 4b0f1a8b pbrook
                break;
3672 4b0f1a8b pbrook
3673 4b0f1a8b pbrook
              case 'U':
3674 4b0f1a8b pbrook
                switch (given & 0xf)
3675 4b0f1a8b pbrook
                  {
3676 4b0f1a8b pbrook
                  case 0xf: func(stream, "sy"); break;
3677 4b0f1a8b pbrook
                  case 0x7: func(stream, "un"); break;
3678 4b0f1a8b pbrook
                  case 0xe: func(stream, "st"); break;
3679 4b0f1a8b pbrook
                  case 0x6: func(stream, "unst"); break;
3680 4b0f1a8b pbrook
                  default:
3681 4b0f1a8b pbrook
                    func(stream, "#%d", (int)given & 0xf);
3682 4b0f1a8b pbrook
                    break;
3683 4b0f1a8b pbrook
                  }
3684 4b0f1a8b pbrook
                break;
3685 4b0f1a8b pbrook
3686 4b0f1a8b pbrook
              case 'C':
3687 4b0f1a8b pbrook
                if ((given & 0xff) == 0)
3688 4b0f1a8b pbrook
                  {
3689 4b0f1a8b pbrook
                    func (stream, "%cPSR_", (given & 0x100000) ? 'S' : 'C');
3690 4b0f1a8b pbrook
                    if (given & 0x800)
3691 4b0f1a8b pbrook
                      func (stream, "f");
3692 4b0f1a8b pbrook
                    if (given & 0x400)
3693 4b0f1a8b pbrook
                      func (stream, "s");
3694 4b0f1a8b pbrook
                    if (given & 0x200)
3695 4b0f1a8b pbrook
                      func (stream, "x");
3696 4b0f1a8b pbrook
                    if (given & 0x100)
3697 4b0f1a8b pbrook
                      func (stream, "c");
3698 4b0f1a8b pbrook
                  }
3699 4b0f1a8b pbrook
                else
3700 4b0f1a8b pbrook
                  {
3701 07b1a9da Stefan Weil
                    func (stream, "%s", psr_name (given & 0xff));
3702 4b0f1a8b pbrook
                  }
3703 4b0f1a8b pbrook
                break;
3704 4b0f1a8b pbrook
3705 4b0f1a8b pbrook
              case 'D':
3706 4b0f1a8b pbrook
                if ((given & 0xff) == 0)
3707 4b0f1a8b pbrook
                  func (stream, "%cPSR", (given & 0x100000) ? 'S' : 'C');
3708 4b0f1a8b pbrook
                else
3709 07b1a9da Stefan Weil
                  func (stream, "%s", psr_name (given & 0xff));
3710 4b0f1a8b pbrook
                break;
3711 4b0f1a8b pbrook
3712 4b0f1a8b pbrook
              case '0': case '1': case '2': case '3': case '4':
3713 4b0f1a8b pbrook
              case '5': case '6': case '7': case '8': case '9':
3714 4b0f1a8b pbrook
                {
3715 4b0f1a8b pbrook
                  int width;
3716 4b0f1a8b pbrook
                  unsigned long val;
3717 4b0f1a8b pbrook
3718 4b0f1a8b pbrook
                  c = arm_decode_bitfield (c, given, &val, &width);
3719 4b0f1a8b pbrook
3720 4b0f1a8b pbrook
                  switch (*c)
3721 4b0f1a8b pbrook
                    {
3722 4b0f1a8b pbrook
                    case 'd': func (stream, "%lu", val); break;
3723 4b0f1a8b pbrook
                    case 'W': func (stream, "%lu", val * 4); break;
3724 4b0f1a8b pbrook
                    case 'r': func (stream, "%s", arm_regnames[val]); break;
3725 4b0f1a8b pbrook
3726 4b0f1a8b pbrook
                    case 'c':
3727 4b0f1a8b pbrook
                      func (stream, "%s", arm_conditional[val]);
3728 4b0f1a8b pbrook
                      break;
3729 4b0f1a8b pbrook
3730 4b0f1a8b pbrook
                    case '\'':
3731 4b0f1a8b pbrook
                      c++;
3732 4b0f1a8b pbrook
                      if (val == ((1ul << width) - 1))
3733 4b0f1a8b pbrook
                        func (stream, "%c", *c);
3734 4b0f1a8b pbrook
                      break;
3735 4b0f1a8b pbrook
3736 4b0f1a8b pbrook
                    case '`':
3737 4b0f1a8b pbrook
                      c++;
3738 4b0f1a8b pbrook
                      if (val == 0)
3739 4b0f1a8b pbrook
                        func (stream, "%c", *c);
3740 4b0f1a8b pbrook
                      break;
3741 4b0f1a8b pbrook
3742 4b0f1a8b pbrook
                    case '?':
3743 4b0f1a8b pbrook
                      func (stream, "%c", c[(1 << width) - (int)val]);
3744 4b0f1a8b pbrook
                      c += 1 << width;
3745 4b0f1a8b pbrook
                      break;
3746 4b0f1a8b pbrook
3747 4b0f1a8b pbrook
                    default:
3748 4b0f1a8b pbrook
                      abort ();
3749 4b0f1a8b pbrook
                    }
3750 4b0f1a8b pbrook
                }
3751 4b0f1a8b pbrook
                break;
3752 3b46e624 ths
3753 4b0f1a8b pbrook
              default:
3754 4b0f1a8b pbrook
                abort ();
3755 4b0f1a8b pbrook
              }
3756 4b0f1a8b pbrook
          }
3757 4b0f1a8b pbrook
        return;
3758 4b0f1a8b pbrook
      }
3759 4b0f1a8b pbrook
3760 4b0f1a8b pbrook
  /* No match.  */
3761 4b0f1a8b pbrook
  abort ();
3762 aa0aa4fa bellard
}
3763 aa0aa4fa bellard
3764 4b0f1a8b pbrook
/* Print data bytes on INFO->STREAM.  */
3765 aa0aa4fa bellard
3766 aa0aa4fa bellard
static void
3767 4b0f1a8b pbrook
print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED, struct disassemble_info *info,
3768 4b0f1a8b pbrook
                 long given)
3769 aa0aa4fa bellard
{
3770 4b0f1a8b pbrook
  switch (info->bytes_per_chunk)
3771 4b0f1a8b pbrook
    {
3772 4b0f1a8b pbrook
    case 1:
3773 4b0f1a8b pbrook
      info->fprintf_func (info->stream, ".byte\t0x%02lx", given);
3774 4b0f1a8b pbrook
      break;
3775 4b0f1a8b pbrook
    case 2:
3776 4b0f1a8b pbrook
      info->fprintf_func (info->stream, ".short\t0x%04lx", given);
3777 4b0f1a8b pbrook
      break;
3778 4b0f1a8b pbrook
    case 4:
3779 4b0f1a8b pbrook
      info->fprintf_func (info->stream, ".word\t0x%08lx", given);
3780 4b0f1a8b pbrook
      break;
3781 4b0f1a8b pbrook
    default:
3782 4b0f1a8b pbrook
      abort ();
3783 4b0f1a8b pbrook
    }
3784 4b0f1a8b pbrook
}
3785 aa0aa4fa bellard
3786 4b0f1a8b pbrook
/* Search back through the insn stream to determine if this instruction is
3787 4b0f1a8b pbrook
   conditionally executed.  */
3788 4b0f1a8b pbrook
static void
3789 4b0f1a8b pbrook
find_ifthen_state (bfd_vma pc, struct disassemble_info *info,
3790 4b0f1a8b pbrook
                   bfd_boolean little)
3791 4b0f1a8b pbrook
{
3792 4b0f1a8b pbrook
  unsigned char b[2];
3793 4b0f1a8b pbrook
  unsigned int insn;
3794 4b0f1a8b pbrook
  int status;
3795 4b0f1a8b pbrook
  /* COUNT is twice the number of instructions seen.  It will be odd if we
3796 4b0f1a8b pbrook
     just crossed an instruction boundary.  */
3797 4b0f1a8b pbrook
  int count;
3798 4b0f1a8b pbrook
  int it_count;
3799 4b0f1a8b pbrook
  unsigned int seen_it;
3800 4b0f1a8b pbrook
  bfd_vma addr;
3801 4b0f1a8b pbrook
3802 4b0f1a8b pbrook
  ifthen_address = pc;
3803 4b0f1a8b pbrook
  ifthen_state = 0;
3804 4b0f1a8b pbrook
3805 4b0f1a8b pbrook
  addr = pc;
3806 4b0f1a8b pbrook
  count = 1;
3807 4b0f1a8b pbrook
  it_count = 0;
3808 4b0f1a8b pbrook
  seen_it = 0;
3809 4b0f1a8b pbrook
  /* Scan backwards looking for IT instructions, keeping track of where
3810 4b0f1a8b pbrook
     instruction boundaries are.  We don't know if something is actually an
3811 4b0f1a8b pbrook
     IT instruction until we find a definite instruction boundary.  */
3812 4b0f1a8b pbrook
  for (;;)
3813 aa0aa4fa bellard
    {
3814 4b0f1a8b pbrook
      if (addr == 0 || info->symbol_at_address_func(addr, info))
3815 4b0f1a8b pbrook
        {
3816 4b0f1a8b pbrook
          /* A symbol must be on an instruction boundary, and will not
3817 4b0f1a8b pbrook
             be within an IT block.  */
3818 4b0f1a8b pbrook
          if (seen_it && (count & 1))
3819 4b0f1a8b pbrook
            break;
3820 4b0f1a8b pbrook
3821 4b0f1a8b pbrook
          return;
3822 4b0f1a8b pbrook
        }
3823 4b0f1a8b pbrook
      addr -= 2;
3824 4b0f1a8b pbrook
      status = info->read_memory_func (addr, (bfd_byte *)b, 2, info);
3825 4b0f1a8b pbrook
      if (status)
3826 4b0f1a8b pbrook
        return;
3827 aa0aa4fa bellard
3828 4b0f1a8b pbrook
      if (little)
3829 4b0f1a8b pbrook
        insn = (b[0]) | (b[1] << 8);
3830 4b0f1a8b pbrook
      else
3831 4b0f1a8b pbrook
        insn = (b[1]) | (b[0] << 8);
3832 4b0f1a8b pbrook
      if (seen_it)
3833 4b0f1a8b pbrook
        {
3834 4b0f1a8b pbrook
          if ((insn & 0xf800) < 0xe800)
3835 4b0f1a8b pbrook
            {
3836 4b0f1a8b pbrook
              /* Addr + 2 is an instruction boundary.  See if this matches
3837 4b0f1a8b pbrook
                 the expected boundary based on the position of the last
3838 4b0f1a8b pbrook
                 IT candidate.  */
3839 4b0f1a8b pbrook
              if (count & 1)
3840 4b0f1a8b pbrook
                break;
3841 4b0f1a8b pbrook
              seen_it = 0;
3842 4b0f1a8b pbrook
            }
3843 4b0f1a8b pbrook
        }
3844 4b0f1a8b pbrook
      if ((insn & 0xff00) == 0xbf00 && (insn & 0xf) != 0)
3845 aa0aa4fa bellard
        {
3846 4b0f1a8b pbrook
          /* This could be an IT instruction.  */
3847 4b0f1a8b pbrook
          seen_it = insn;
3848 4b0f1a8b pbrook
          it_count = count >> 1;
3849 aa0aa4fa bellard
        }
3850 4b0f1a8b pbrook
      if ((insn & 0xf800) >= 0xe800)
3851 4b0f1a8b pbrook
        count++;
3852 aa0aa4fa bellard
      else
3853 4b0f1a8b pbrook
        count = (count + 2) | 1;
3854 4b0f1a8b pbrook
      /* IT blocks contain at most 4 instructions.  */
3855 4b0f1a8b pbrook
      if (count >= 8 && !seen_it)
3856 4b0f1a8b pbrook
        return;
3857 aa0aa4fa bellard
    }
3858 4b0f1a8b pbrook
  /* We found an IT instruction.  */
3859 4b0f1a8b pbrook
  ifthen_state = (seen_it & 0xe0) | ((seen_it << it_count) & 0x1f);
3860 4b0f1a8b pbrook
  if ((ifthen_state & 0xf) == 0)
3861 4b0f1a8b pbrook
    ifthen_state = 0;
3862 aa0aa4fa bellard
}
3863 aa0aa4fa bellard
3864 aa0aa4fa bellard
/* NOTE: There are no checks in these routines that
3865 aa0aa4fa bellard
   the relevant number of data bytes exist.  */
3866 aa0aa4fa bellard
3867 aa0aa4fa bellard
int
3868 4b0f1a8b pbrook
print_insn_arm (bfd_vma pc, struct disassemble_info *info)
3869 aa0aa4fa bellard
{
3870 4b0f1a8b pbrook
  unsigned char b[4];
3871 4b0f1a8b pbrook
  long                given;
3872 4b0f1a8b pbrook
  int           status;
3873 47cbc7aa Juan Quintela
  int           is_thumb = false;
3874 47cbc7aa Juan Quintela
  int           is_data = false;
3875 4b0f1a8b pbrook
  unsigned int        size = 4;
3876 4b0f1a8b pbrook
  void                 (*printer) (bfd_vma, struct disassemble_info *, long);
3877 4b0f1a8b pbrook
#if 0
3878 47cbc7aa Juan Quintela
  bfd_boolean   found = false;
3879 aa0aa4fa bellard

3880 aa0aa4fa bellard
  if (info->disassembler_options)
3881 aa0aa4fa bellard
    {
3882 aa0aa4fa bellard
      parse_disassembler_options (info->disassembler_options);
3883 3b46e624 ths

3884 aa0aa4fa bellard
      /* To avoid repeated parsing of these options, we remove them here.  */
3885 aa0aa4fa bellard
      info->disassembler_options = NULL;
3886 aa0aa4fa bellard
    }
3887 3b46e624 ths

3888 4b0f1a8b pbrook
  /* First check the full symtab for a mapping symbol, even if there
3889 4b0f1a8b pbrook
     are no usable non-mapping symbols for this address.  */
3890 4b0f1a8b pbrook
  if (info->symtab != NULL
3891 4b0f1a8b pbrook
      && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
3892 c2d551ff bellard
    {
3893 4b0f1a8b pbrook
      bfd_vma addr;
3894 4b0f1a8b pbrook
      int n;
3895 4b0f1a8b pbrook
      int last_sym = -1;
3896 4b0f1a8b pbrook
      enum map_type type = MAP_ARM;
3897 4b0f1a8b pbrook

3898 4b0f1a8b pbrook
      if (pc <= last_mapping_addr)
3899 4b0f1a8b pbrook
        last_mapping_sym = -1;
3900 4b0f1a8b pbrook
      is_thumb = (last_type == MAP_THUMB);
3901 47cbc7aa Juan Quintela
      found = false;
3902 4b0f1a8b pbrook
      /* Start scanning at the start of the function, or wherever
3903 4b0f1a8b pbrook
         we finished last time.  */
3904 4b0f1a8b pbrook
      n = info->symtab_pos + 1;
3905 4b0f1a8b pbrook
      if (n < last_mapping_sym)
3906 4b0f1a8b pbrook
        n = last_mapping_sym;
3907 4b0f1a8b pbrook

3908 4b0f1a8b pbrook
      /* Scan up to the location being disassembled.  */
3909 4b0f1a8b pbrook
      for (; n < info->symtab_size; n++)
3910 4b0f1a8b pbrook
        {
3911 4b0f1a8b pbrook
          addr = bfd_asymbol_value (info->symtab[n]);
3912 4b0f1a8b pbrook
          if (addr > pc)
3913 4b0f1a8b pbrook
            break;
3914 4b0f1a8b pbrook
          if ((info->section == NULL
3915 4b0f1a8b pbrook
               || info->section == info->symtab[n]->section)
3916 4b0f1a8b pbrook
              && get_sym_code_type (info, n, &type))
3917 4b0f1a8b pbrook
            {
3918 4b0f1a8b pbrook
              last_sym = n;
3919 47cbc7aa Juan Quintela
              found = true;
3920 4b0f1a8b pbrook
            }
3921 4b0f1a8b pbrook
        }
3922 4b0f1a8b pbrook

3923 4b0f1a8b pbrook
      if (!found)
3924 4b0f1a8b pbrook
        {
3925 4b0f1a8b pbrook
          n = info->symtab_pos;
3926 4b0f1a8b pbrook
          if (n < last_mapping_sym - 1)
3927 4b0f1a8b pbrook
            n = last_mapping_sym - 1;
3928 4b0f1a8b pbrook

3929 4b0f1a8b pbrook
          /* No mapping symbol found at this address.  Look backwards
3930 4b0f1a8b pbrook
             for a preceeding one.  */
3931 4b0f1a8b pbrook
          for (; n >= 0; n--)
3932 4b0f1a8b pbrook
            {
3933 4b0f1a8b pbrook
              if (get_sym_code_type (info, n, &type))
3934 4b0f1a8b pbrook
                {
3935 4b0f1a8b pbrook
                  last_sym = n;
3936 47cbc7aa Juan Quintela
                  found = true;
3937 4b0f1a8b pbrook
                  break;
3938 4b0f1a8b pbrook
                }
3939 4b0f1a8b pbrook
            }
3940 4b0f1a8b pbrook
        }
3941 4b0f1a8b pbrook

3942 4b0f1a8b pbrook
      last_mapping_sym = last_sym;
3943 4b0f1a8b pbrook
      last_type = type;
3944 4b0f1a8b pbrook
      is_thumb = (last_type == MAP_THUMB);
3945 4b0f1a8b pbrook
      is_data = (last_type == MAP_DATA);
3946 4b0f1a8b pbrook

3947 4b0f1a8b pbrook
      /* Look a little bit ahead to see if we should print out
3948 4b0f1a8b pbrook
         two or four bytes of data.  If there's a symbol,
3949 4b0f1a8b pbrook
         mapping or otherwise, after two bytes then don't
3950 4b0f1a8b pbrook
         print more.  */
3951 4b0f1a8b pbrook
      if (is_data)
3952 4b0f1a8b pbrook
        {
3953 4b0f1a8b pbrook
          size = 4 - (pc & 3);
3954 4b0f1a8b pbrook
          for (n = last_sym + 1; n < info->symtab_size; n++)
3955 4b0f1a8b pbrook
            {
3956 4b0f1a8b pbrook
              addr = bfd_asymbol_value (info->symtab[n]);
3957 4b0f1a8b pbrook
              if (addr > pc)
3958 4b0f1a8b pbrook
                {
3959 4b0f1a8b pbrook
                  if (addr - pc < size)
3960 4b0f1a8b pbrook
                    size = addr - pc;
3961 4b0f1a8b pbrook
                  break;
3962 4b0f1a8b pbrook
                }
3963 4b0f1a8b pbrook
            }
3964 4b0f1a8b pbrook
          /* If the next symbol is after three bytes, we need to
3965 4b0f1a8b pbrook
             print only part of the data, so that we can use either
3966 4b0f1a8b pbrook
             .byte or .short.  */
3967 4b0f1a8b pbrook
          if (size == 3)
3968 4b0f1a8b pbrook
            size = (pc & 1) ? 1 : 2;
3969 4b0f1a8b pbrook
        }
3970 c2d551ff bellard
    }
3971 3b46e624 ths

3972 4b0f1a8b pbrook
  if (info->symbols != NULL)
3973 aa0aa4fa bellard
    {
3974 aa0aa4fa bellard
      if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)
3975 aa0aa4fa bellard
        {
3976 aa0aa4fa bellard
          coff_symbol_type * cs;
3977 3b46e624 ths

3978 aa0aa4fa bellard
          cs = coffsymbol (*info->symbols);
3979 aa0aa4fa bellard
          is_thumb = (   cs->native->u.syment.n_sclass == C_THUMBEXT
3980 aa0aa4fa bellard
                      || cs->native->u.syment.n_sclass == C_THUMBSTAT
3981 aa0aa4fa bellard
                      || cs->native->u.syment.n_sclass == C_THUMBLABEL
3982 aa0aa4fa bellard
                      || cs->native->u.syment.n_sclass == C_THUMBEXTFUNC
3983 aa0aa4fa bellard
                      || cs->native->u.syment.n_sclass == C_THUMBSTATFUNC);
3984 aa0aa4fa bellard
        }
3985 4b0f1a8b pbrook
      else if (bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
3986 4b0f1a8b pbrook
               && !found)
3987 aa0aa4fa bellard
        {
3988 4b0f1a8b pbrook
          /* If no mapping symbol has been found then fall back to the type
3989 4b0f1a8b pbrook
             of the function symbol.  */
3990 aa0aa4fa bellard
          elf_symbol_type *  es;
3991 aa0aa4fa bellard
          unsigned int       type;
3992 3b46e624 ths

3993 aa0aa4fa bellard
          es = *(elf_symbol_type **)(info->symbols);
3994 aa0aa4fa bellard
          type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
3995 3b46e624 ths

3996 aa0aa4fa bellard
          is_thumb = (type == STT_ARM_TFUNC) || (type == STT_ARM_16BIT);
3997 aa0aa4fa bellard
        }
3998 aa0aa4fa bellard
    }
3999 4b0f1a8b pbrook
#else
4000 4b0f1a8b pbrook
  int little;
4001 3b46e624 ths
4002 aa0aa4fa bellard
  little = (info->endian == BFD_ENDIAN_LITTLE);
4003 4b0f1a8b pbrook
  is_thumb |= (pc & 1);
4004 4b0f1a8b pbrook
  pc &= ~(bfd_vma)1;
4005 4b0f1a8b pbrook
#endif
4006 aa0aa4fa bellard
4007 4b0f1a8b pbrook
  if (force_thumb)
4008 47cbc7aa Juan Quintela
    is_thumb = true;
4009 3b46e624 ths
4010 4b0f1a8b pbrook
  info->bytes_per_line = 4;
4011 3b46e624 ths
4012 4b0f1a8b pbrook
  if (is_data)
4013 4b0f1a8b pbrook
    {
4014 4b0f1a8b pbrook
      int i;
4015 4b0f1a8b pbrook
4016 4b0f1a8b pbrook
      /* size was already set above.  */
4017 4b0f1a8b pbrook
      info->bytes_per_chunk = size;
4018 4b0f1a8b pbrook
      printer = print_insn_data;
4019 3b46e624 ths
4020 4b0f1a8b pbrook
      status = info->read_memory_func (pc, (bfd_byte *)b, size, info);
4021 4b0f1a8b pbrook
      given = 0;
4022 4b0f1a8b pbrook
      if (little)
4023 4b0f1a8b pbrook
        for (i = size - 1; i >= 0; i--)
4024 4b0f1a8b pbrook
          given = b[i] | (given << 8);
4025 4b0f1a8b pbrook
      else
4026 4b0f1a8b pbrook
        for (i = 0; i < (int) size; i++)
4027 4b0f1a8b pbrook
          given = b[i] | (given << 8);
4028 4b0f1a8b pbrook
    }
4029 4b0f1a8b pbrook
  else if (!is_thumb)
4030 4b0f1a8b pbrook
    {
4031 4b0f1a8b pbrook
      /* In ARM mode endianness is a straightforward issue: the instruction
4032 4b0f1a8b pbrook
         is four bytes long and is either ordered 0123 or 3210.  */
4033 4b0f1a8b pbrook
      printer = print_insn_arm_internal;
4034 4b0f1a8b pbrook
      info->bytes_per_chunk = 4;
4035 4b0f1a8b pbrook
      size = 4;
4036 4b0f1a8b pbrook
4037 4b0f1a8b pbrook
      status = info->read_memory_func (pc, (bfd_byte *)b, 4, info);
4038 4b0f1a8b pbrook
      if (little)
4039 4b0f1a8b pbrook
        given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
4040 4b0f1a8b pbrook
      else
4041 4b0f1a8b pbrook
        given = (b[3]) | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
4042 aa0aa4fa bellard
    }
4043 aa0aa4fa bellard
  else
4044 aa0aa4fa bellard
    {
4045 4b0f1a8b pbrook
      /* In Thumb mode we have the additional wrinkle of two
4046 4b0f1a8b pbrook
         instruction lengths.  Fortunately, the bits that determine
4047 4b0f1a8b pbrook
         the length of the current instruction are always to be found
4048 4b0f1a8b pbrook
         in the first two bytes.  */
4049 4b0f1a8b pbrook
      printer = print_insn_thumb16;
4050 4b0f1a8b pbrook
      info->bytes_per_chunk = 2;
4051 4b0f1a8b pbrook
      size = 2;
4052 4b0f1a8b pbrook
4053 4b0f1a8b pbrook
      status = info->read_memory_func (pc, (bfd_byte *)b, 2, info);
4054 4b0f1a8b pbrook
      if (little)
4055 4b0f1a8b pbrook
        given = (b[0]) | (b[1] << 8);
4056 4b0f1a8b pbrook
      else
4057 4b0f1a8b pbrook
        given = (b[1]) | (b[0] << 8);
4058 3b46e624 ths
4059 4b0f1a8b pbrook
      if (!status)
4060 aa0aa4fa bellard
        {
4061 4b0f1a8b pbrook
          /* These bit patterns signal a four-byte Thumb
4062 4b0f1a8b pbrook
             instruction.  */
4063 4b0f1a8b pbrook
          if ((given & 0xF800) == 0xF800
4064 4b0f1a8b pbrook
              || (given & 0xF800) == 0xF000
4065 4b0f1a8b pbrook
              || (given & 0xF800) == 0xE800)
4066 aa0aa4fa bellard
            {
4067 4b0f1a8b pbrook
              status = info->read_memory_func (pc + 2, (bfd_byte *)b, 2, info);
4068 4b0f1a8b pbrook
              if (little)
4069 4b0f1a8b pbrook
                given = (b[0]) | (b[1] << 8) | (given << 16);
4070 4b0f1a8b pbrook
              else
4071 4b0f1a8b pbrook
                given = (b[1]) | (b[0] << 8) | (given << 16);
4072 3b46e624 ths
4073 4b0f1a8b pbrook
              printer = print_insn_thumb32;
4074 4b0f1a8b pbrook
              size = 4;
4075 aa0aa4fa bellard
            }
4076 4b0f1a8b pbrook
        }
4077 4b0f1a8b pbrook
4078 4b0f1a8b pbrook
      if (ifthen_address != pc)
4079 4b0f1a8b pbrook
        find_ifthen_state(pc, info, little);
4080 4b0f1a8b pbrook
4081 4b0f1a8b pbrook
      if (ifthen_state)
4082 4b0f1a8b pbrook
        {
4083 4b0f1a8b pbrook
          if ((ifthen_state & 0xf) == 0x8)
4084 4b0f1a8b pbrook
            ifthen_next_state = 0;
4085 aa0aa4fa bellard
          else
4086 4b0f1a8b pbrook
            ifthen_next_state = (ifthen_state & 0xe0)
4087 4b0f1a8b pbrook
                                | ((ifthen_state & 0xf) << 1);
4088 aa0aa4fa bellard
        }
4089 aa0aa4fa bellard
    }
4090 3b46e624 ths
4091 4b0f1a8b pbrook
  if (status)
4092 4b0f1a8b pbrook
    {
4093 4b0f1a8b pbrook
      info->memory_error_func (status, pc, info);
4094 4b0f1a8b pbrook
      return -1;
4095 4b0f1a8b pbrook
    }
4096 aa0aa4fa bellard
  if (info->flags & INSN_HAS_RELOC)
4097 aa0aa4fa bellard
    /* If the instruction has a reloc associated with it, then
4098 aa0aa4fa bellard
       the offset field in the instruction will actually be the
4099 aa0aa4fa bellard
       addend for the reloc.  (We are using REL type relocs).
4100 aa0aa4fa bellard
       In such cases, we can ignore the pc when computing
4101 aa0aa4fa bellard
       addresses, since the addend is not currently pc-relative.  */
4102 aa0aa4fa bellard
    pc = 0;
4103 aa0aa4fa bellard
4104 5d48e917 Peter Maydell
  /* We include the hexdump of the instruction. The format here
4105 5d48e917 Peter Maydell
     matches that used by objdump and the ARM ARM (in particular,
4106 5d48e917 Peter Maydell
     32 bit Thumb instructions are displayed as pairs of halfwords,
4107 5d48e917 Peter Maydell
     not as a single word.)  */
4108 5d48e917 Peter Maydell
  if (is_thumb)
4109 5d48e917 Peter Maydell
    {
4110 5d48e917 Peter Maydell
      if (size == 2)
4111 5d48e917 Peter Maydell
        {
4112 5d48e917 Peter Maydell
          info->fprintf_func(info->stream, "%04lx       ",
4113 5d48e917 Peter Maydell
                             ((unsigned long)given) & 0xffff);
4114 5d48e917 Peter Maydell
        }
4115 5d48e917 Peter Maydell
      else
4116 5d48e917 Peter Maydell
        {
4117 5d48e917 Peter Maydell
          info->fprintf_func(info->stream, "%04lx %04lx  ",
4118 5d48e917 Peter Maydell
                             (((unsigned long)given) >> 16) & 0xffff,
4119 5d48e917 Peter Maydell
                             ((unsigned long)given) & 0xffff);
4120 5d48e917 Peter Maydell
        }
4121 5d48e917 Peter Maydell
    }
4122 5d48e917 Peter Maydell
  else
4123 5d48e917 Peter Maydell
    {
4124 5d48e917 Peter Maydell
      info->fprintf_func(info->stream, "%08lx      ",
4125 5d48e917 Peter Maydell
                         ((unsigned long)given) & 0xffffffff);
4126 5d48e917 Peter Maydell
    }
4127 5d48e917 Peter Maydell
4128 4b0f1a8b pbrook
  printer (pc, info, given);
4129 4b0f1a8b pbrook
4130 4b0f1a8b pbrook
  if (is_thumb)
4131 4b0f1a8b pbrook
    {
4132 4b0f1a8b pbrook
      ifthen_state = ifthen_next_state;
4133 4b0f1a8b pbrook
      ifthen_address += size;
4134 4b0f1a8b pbrook
    }
4135 4b0f1a8b pbrook
  return size;
4136 aa0aa4fa bellard
}