Statistics
| Branch: | Revision:

root / arm-dis.c @ 2a424990

History | View | Annotate | Download (156.6 kB)

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

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

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

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

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

103 aa0aa4fa bellard
   %%                        %
104 4b0f1a8b pbrook

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

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

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

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

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

507 4b0f1a8b pbrook
   %%                        %
508 4b0f1a8b pbrook

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

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

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

784 4b0f1a8b pbrook
   %%                        %
785 4b0f1a8b pbrook

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

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

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

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

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

1222 4b0f1a8b pbrook
   print_insn_thumb32 recognizes the following format control codes:
1223 4b0f1a8b pbrook

1224 4b0f1a8b pbrook
       %%                %
1225 4b0f1a8b pbrook

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

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

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

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

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

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

3885 aa0aa4fa bellard
  if (info->disassembler_options)
3886 aa0aa4fa bellard
    {
3887 aa0aa4fa bellard
      parse_disassembler_options (info->disassembler_options);
3888 3b46e624 ths

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

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

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

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

3928 4b0f1a8b pbrook
      if (!found)
3929 4b0f1a8b pbrook
        {
3930 4b0f1a8b pbrook
          n = info->symtab_pos;
3931 4b0f1a8b pbrook
          if (n < last_mapping_sym - 1)
3932 4b0f1a8b pbrook
            n = last_mapping_sym - 1;
3933 4b0f1a8b pbrook

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

3947 4b0f1a8b pbrook
      last_mapping_sym = last_sym;
3948 4b0f1a8b pbrook
      last_type = type;
3949 4b0f1a8b pbrook
      is_thumb = (last_type == MAP_THUMB);
3950 4b0f1a8b pbrook
      is_data = (last_type == MAP_DATA);
3951 4b0f1a8b pbrook

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

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

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

3998 aa0aa4fa bellard
          es = *(elf_symbol_type **)(info->symbols);
3999 aa0aa4fa bellard
          type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
4000 3b46e624 ths

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