Statistics
| Branch: | Revision:

root / arm-dis.c @ 856ae5c3

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

106 aa0aa4fa bellard
   %%                        %
107 4b0f1a8b pbrook

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

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

133 4b0f1a8b pbrook
   %y<code>                print a single precision VFP reg.
134 aa0aa4fa bellard
                          Codes: 0=>Sm, 1=>Sd, 2=>Sn, 3=>multi-list, 4=>Sm pair
135 4b0f1a8b pbrook
   %z<code>                print a double precision VFP reg
136 aa0aa4fa bellard
                          Codes: 0=>Dm, 1=>Dd, 2=>Dn, 3=>multi-list
137 4b0f1a8b pbrook

138 4b0f1a8b pbrook
   %<bitfield>'c        print specified char iff bitfield is all ones
139 4b0f1a8b pbrook
   %<bitfield>`c        print specified char iff bitfield is all zeroes
140 4b0f1a8b pbrook
   %<bitfield>?ab...    select from array of values in big endian order
141 4b0f1a8b pbrook

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

510 4b0f1a8b pbrook
   %%                        %
511 4b0f1a8b pbrook

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

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

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

787 4b0f1a8b pbrook
   %%                        %
788 4b0f1a8b pbrook

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

802 4b0f1a8b pbrook
   %<bitfield>r                print as an ARM register
803 4b0f1a8b pbrook
   %<bitfield>d                print the bitfield in decimal
804 4b0f1a8b pbrook
   %<bitfield>W         print the bitfield plus one in decimal
805 4b0f1a8b pbrook
   %<bitfield>x                print the bitfield in hex
806 4b0f1a8b pbrook
   %<bitfield>X                print the bitfield as 1 hex digit without leading "0x"
807 4b0f1a8b pbrook

808 4b0f1a8b pbrook
   %<bitfield>'c        print specified char iff bitfield is all ones
809 4b0f1a8b pbrook
   %<bitfield>`c        print specified char iff bitfield is all zeroes
810 4b0f1a8b pbrook
   %<bitfield>?ab...    select from array of values in big endian order
811 4b0f1a8b pbrook

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

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

1225 4b0f1a8b pbrook
   print_insn_thumb32 recognizes the following format control codes:
1226 4b0f1a8b pbrook

1227 4b0f1a8b pbrook
       %%                %
1228 4b0f1a8b pbrook

1229 4b0f1a8b pbrook
       %I                print a 12-bit immediate from hw1[10],hw2[14:12,7:0]
1230 4b0f1a8b pbrook
       %M                print a modified 12-bit immediate (same location)
1231 4b0f1a8b pbrook
       %J                print a 16-bit immediate from hw1[3:0,10],hw2[14:12,7:0]
1232 4b0f1a8b pbrook
       %K                print a 16-bit immediate from hw2[3:0],hw1[3:0],hw2[11:4]
1233 4b0f1a8b pbrook
       %S                print a possibly-shifted Rm
1234 4b0f1a8b pbrook

1235 4b0f1a8b pbrook
       %a                print the address of a plain load/store
1236 4b0f1a8b pbrook
       %w                print the width and signedness of a core load/store
1237 4b0f1a8b pbrook
       %m                print register mask for ldm/stm
1238 4b0f1a8b pbrook

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

1251 4b0f1a8b pbrook
       %<bitfield>d        print bitfield in decimal
1252 4b0f1a8b pbrook
       %<bitfield>W        print bitfield*4 in decimal
1253 4b0f1a8b pbrook
       %<bitfield>r        print bitfield as an ARM register
1254 4b0f1a8b pbrook
       %<bitfield>c        print bitfield as a condition code
1255 4b0f1a8b pbrook

1256 4b0f1a8b pbrook
       %<bitfield>'c        print specified char iff bitfield is all ones
1257 4b0f1a8b pbrook
       %<bitfield>`c        print specified char iff bitfield is all zeroes
1258 4b0f1a8b pbrook
       %<bitfield>?ab... select from array of values in big endian order
1259 4b0f1a8b pbrook

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

3888 aa0aa4fa bellard
  if (info->disassembler_options)
3889 aa0aa4fa bellard
    {
3890 aa0aa4fa bellard
      parse_disassembler_options (info->disassembler_options);
3891 3b46e624 ths

3892 aa0aa4fa bellard
      /* To avoid repeated parsing of these options, we remove them here.  */
3893 aa0aa4fa bellard
      info->disassembler_options = NULL;
3894 aa0aa4fa bellard
    }
3895 3b46e624 ths

3896 4b0f1a8b pbrook
  /* First check the full symtab for a mapping symbol, even if there
3897 4b0f1a8b pbrook
     are no usable non-mapping symbols for this address.  */
3898 4b0f1a8b pbrook
  if (info->symtab != NULL
3899 4b0f1a8b pbrook
      && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
3900 c2d551ff bellard
    {
3901 4b0f1a8b pbrook
      bfd_vma addr;
3902 4b0f1a8b pbrook
      int n;
3903 4b0f1a8b pbrook
      int last_sym = -1;
3904 4b0f1a8b pbrook
      enum map_type type = MAP_ARM;
3905 4b0f1a8b pbrook

3906 4b0f1a8b pbrook
      if (pc <= last_mapping_addr)
3907 4b0f1a8b pbrook
        last_mapping_sym = -1;
3908 4b0f1a8b pbrook
      is_thumb = (last_type == MAP_THUMB);
3909 4b0f1a8b pbrook
      found = FALSE;
3910 4b0f1a8b pbrook
      /* Start scanning at the start of the function, or wherever
3911 4b0f1a8b pbrook
         we finished last time.  */
3912 4b0f1a8b pbrook
      n = info->symtab_pos + 1;
3913 4b0f1a8b pbrook
      if (n < last_mapping_sym)
3914 4b0f1a8b pbrook
        n = last_mapping_sym;
3915 4b0f1a8b pbrook

3916 4b0f1a8b pbrook
      /* Scan up to the location being disassembled.  */
3917 4b0f1a8b pbrook
      for (; n < info->symtab_size; n++)
3918 4b0f1a8b pbrook
        {
3919 4b0f1a8b pbrook
          addr = bfd_asymbol_value (info->symtab[n]);
3920 4b0f1a8b pbrook
          if (addr > pc)
3921 4b0f1a8b pbrook
            break;
3922 4b0f1a8b pbrook
          if ((info->section == NULL
3923 4b0f1a8b pbrook
               || info->section == info->symtab[n]->section)
3924 4b0f1a8b pbrook
              && get_sym_code_type (info, n, &type))
3925 4b0f1a8b pbrook
            {
3926 4b0f1a8b pbrook
              last_sym = n;
3927 4b0f1a8b pbrook
              found = TRUE;
3928 4b0f1a8b pbrook
            }
3929 4b0f1a8b pbrook
        }
3930 4b0f1a8b pbrook

3931 4b0f1a8b pbrook
      if (!found)
3932 4b0f1a8b pbrook
        {
3933 4b0f1a8b pbrook
          n = info->symtab_pos;
3934 4b0f1a8b pbrook
          if (n < last_mapping_sym - 1)
3935 4b0f1a8b pbrook
            n = last_mapping_sym - 1;
3936 4b0f1a8b pbrook

3937 4b0f1a8b pbrook
          /* No mapping symbol found at this address.  Look backwards
3938 4b0f1a8b pbrook
             for a preceeding one.  */
3939 4b0f1a8b pbrook
          for (; n >= 0; n--)
3940 4b0f1a8b pbrook
            {
3941 4b0f1a8b pbrook
              if (get_sym_code_type (info, n, &type))
3942 4b0f1a8b pbrook
                {
3943 4b0f1a8b pbrook
                  last_sym = n;
3944 4b0f1a8b pbrook
                  found = TRUE;
3945 4b0f1a8b pbrook
                  break;
3946 4b0f1a8b pbrook
                }
3947 4b0f1a8b pbrook
            }
3948 4b0f1a8b pbrook
        }
3949 4b0f1a8b pbrook

3950 4b0f1a8b pbrook
      last_mapping_sym = last_sym;
3951 4b0f1a8b pbrook
      last_type = type;
3952 4b0f1a8b pbrook
      is_thumb = (last_type == MAP_THUMB);
3953 4b0f1a8b pbrook
      is_data = (last_type == MAP_DATA);
3954 4b0f1a8b pbrook

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

3980 4b0f1a8b pbrook
  if (info->symbols != NULL)
3981 aa0aa4fa bellard
    {
3982 aa0aa4fa bellard
      if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)
3983 aa0aa4fa bellard
        {
3984 aa0aa4fa bellard
          coff_symbol_type * cs;
3985 3b46e624 ths

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

4001 aa0aa4fa bellard
          es = *(elf_symbol_type **)(info->symbols);
4002 aa0aa4fa bellard
          type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
4003 3b46e624 ths

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