1 /* Instruction printing code for the ARM
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 2007, Free Software Foundation, Inc.
4 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
5 Modification by James G. Smith (jsmith@cygnus.co.uk)
6
7 This file is part of libopcodes.
8
9 This program is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2 of the License, or (at your option)
12 any later version.
13
14 This program is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24
25 #include "dis-asm.h"
26 #include "opcode/arm.h"
27 #include "opintl.h"
28 #include "safe-ctype.h"
29 #include "floatformat.h"
30
31 /* FIXME: This shouldn't be done here. */
32 #include "coff/internal.h"
33 #include "libcoff.h"
34 #include "elf-bfd.h"
35 #include "elf/internal.h"
36 #include "elf/arm.h"
37
38 /* FIXME: Belongs in global header. */
39 #ifndef strneq
40 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
41 #endif
42
43 #ifndef NUM_ELEM
44 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
45 #endif
46
47 struct opcode32
48 {
49 unsigned long arch; /* Architecture defining this insn. */
50 unsigned long value, mask; /* Recognise insn if (op&mask)==value. */
51 const char *assembler; /* How to disassemble this insn. */
52 };
53
54 struct opcode16
55 {
56 unsigned long arch; /* Architecture defining this insn. */
57 unsigned short value, mask; /* Recognise insn if (op&mask)==value. */
58 const char *assembler; /* How to disassemble this insn. */
59 };
60
61 /* print_insn_coprocessor recognizes the following format control codes:
62
63 %% %
64
65 %c print condition code (always bits 28-31 in ARM mode)
66 %q print shifter argument
67 %u print condition code (unconditional in ARM mode)
68 %A print address for ldc/stc/ldf/stf instruction
69 %B print vstm/vldm register list
70 %C print vstr/vldr address operand
71 %I print cirrus signed shift immediate: bits 0..3|4..6
72 %F print the COUNT field of a LFM/SFM instruction.
73 %P print floating point precision in arithmetic insn
74 %Q print floating point precision in ldf/stf insn
75 %R print floating point rounding mode
76
77 %<bitfield>r print as an ARM register
78 %<bitfield>d print the bitfield in decimal
79 %<bitfield>k print immediate for VFPv3 conversion instruction
80 %<bitfield>x print the bitfield in hex
81 %<bitfield>X print the bitfield as 1 hex digit without leading "0x"
82 %<bitfield>f print a floating point constant if >7 else a
83 floating point register
84 %<bitfield>w print as an iWMMXt width field - [bhwd]ss/us
85 %<bitfield>g print as an iWMMXt 64-bit register
86 %<bitfield>G print as an iWMMXt general purpose or control register
87 %<bitfield>D print as a NEON D register
88 %<bitfield>Q print as a NEON Q register
89
90 %y<code> print a single precision VFP reg.
91 Codes: 0=>Sm, 1=>Sd, 2=>Sn, 3=>multi-list, 4=>Sm pair
92 %z<code> print a double precision VFP reg
93 Codes: 0=>Dm, 1=>Dd, 2=>Dn, 3=>multi-list
94
95 %<bitfield>'c print specified char iff bitfield is all ones
96 %<bitfield>`c print specified char iff bitfield is all zeroes
97 %<bitfield>?ab... select from array of values in big endian order
98
99 %L print as an iWMMXt N/M width field.
100 %Z print the Immediate of a WSHUFH instruction.
101 %l like 'A' except use byte offsets for 'B' & 'H'
102 versions.
103 %i print 5-bit immediate in bits 8,3..0
104 (print "32" when 0)
105 %r print register offset address for wldt/wstr instruction
106 */
107
108 /* Common coprocessor opcodes shared between Arm and Thumb-2. */
109
110 static const struct opcode32 coprocessor_opcodes[] =
111 {
112 /* XScale instructions. */
113 {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0ff0, "mia%c\tacc0, %0-3r, %12-15r"},
114 {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0ff0, "miaph%c\tacc0, %0-3r, %12-15r"},
115 {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0ff0, "mia%17'T%17`B%16'T%16`B%c\tacc0, %0-3r, %12-15r"},
116 {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00fff, "mar%c\tacc0, %12-15r, %16-19r"},
117 {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00fff, "mra%c\t%12-15r, %16-19r, acc0"},
118
119 /* Intel Wireless MMX technology instructions. */
120 #define FIRST_IWMMXT_INSN 0x0e130130
121 #define IWMMXT_INSN_COUNT 73
122 {ARM_CEXT_IWMMXT, 0x0e130130, 0x0f3f0fff, "tandc%22-23w%c\t%12-15r"},
123 {ARM_CEXT_XSCALE, 0x0e400010, 0x0ff00f3f, "tbcst%6-7w%c\t%16-19g, %12-15r"},
124 {ARM_CEXT_XSCALE, 0x0e130170, 0x0f3f0ff8, "textrc%22-23w%c\t%12-15r, #%0-2d"},
125 {ARM_CEXT_XSCALE, 0x0e100070, 0x0f300ff0, "textrm%3?su%22-23w%c\t%12-15r, %16-19g, #%0-2d"},
126 {ARM_CEXT_XSCALE, 0x0e600010, 0x0ff00f38, "tinsr%6-7w%c\t%16-19g, %12-15r, #%0-2d"},
127 {ARM_CEXT_XSCALE, 0x0e000110, 0x0ff00fff, "tmcr%c\t%16-19G, %12-15r"},
128 {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00ff0, "tmcrr%c\t%0-3g, %12-15r, %16-19r"},
129 {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0e10, "tmia%17?tb%16?tb%c\t%5-8g, %0-3r, %12-15r"},
130 {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0e10, "tmia%c\t%5-8g, %0-3r, %12-15r"},
131 {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0e10, "tmiaph%c\t%5-8g, %0-3r, %12-15r"},
132 {ARM_CEXT_XSCALE, 0x0e100030, 0x0f300fff, "tmovmsk%22-23w%c\t%12-15r, %16-19g"},
133 {ARM_CEXT_XSCALE, 0x0e100110, 0x0ff00ff0, "tmrc%c\t%12-15r, %16-19G"},
134 {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00ff0, "tmrrc%c\t%12-15r, %16-19r, %0-3g"},
135 {ARM_CEXT_XSCALE, 0x0e130150, 0x0f3f0fff, "torc%22-23w%c\t%12-15r"},
136 {ARM_CEXT_XSCALE, 0x0e130190, 0x0f3f0fff, "torvsc%22-23w%c\t%12-15r"},
137 {ARM_CEXT_XSCALE, 0x0e2001c0, 0x0f300fff, "wabs%22-23w%c\t%12-15g, %16-19g"},
138 {ARM_CEXT_XSCALE, 0x0e0001c0, 0x0f300fff, "wacc%22-23w%c\t%12-15g, %16-19g"},
139 {ARM_CEXT_XSCALE, 0x0e000180, 0x0f000ff0, "wadd%20-23w%c\t%12-15g, %16-19g, %0-3g"},
140 {ARM_CEXT_XSCALE, 0x0e2001a0, 0x0f300ff0, "waddbhus%22?ml%c\t%12-15g, %16-19g, %0-3g"},
141 {ARM_CEXT_XSCALE, 0x0ea001a0, 0x0ff00ff0, "waddsubhx%c\t%12-15g, %16-19g, %0-3g"},
142 {ARM_CEXT_XSCALE, 0x0e000020, 0x0f800ff0, "waligni%c\t%12-15g, %16-19g, %0-3g, #%20-22d"},
143 {ARM_CEXT_XSCALE, 0x0e800020, 0x0fc00ff0, "walignr%20-21d%c\t%12-15g, %16-19g, %0-3g"},
144 {ARM_CEXT_XSCALE, 0x0e200000, 0x0fe00ff0, "wand%20'n%c\t%12-15g, %16-19g, %0-3g"},
145 {ARM_CEXT_XSCALE, 0x0e800000, 0x0fa00ff0, "wavg2%22?hb%20'r%c\t%12-15g, %16-19g, %0-3g"},
146 {ARM_CEXT_XSCALE, 0x0e400000, 0x0fe00ff0, "wavg4%20'r%c\t%12-15g, %16-19g, %0-3g"},
147 {ARM_CEXT_XSCALE, 0x0e000060, 0x0f300ff0, "wcmpeq%22-23w%c\t%12-15g, %16-19g, %0-3g"},
148 {ARM_CEXT_XSCALE, 0x0e100060, 0x0f100ff0, "wcmpgt%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
149 {ARM_CEXT_XSCALE, 0xfc500100, 0xfe500f00, "wldrd\t%12-15g, %r"},
150 {ARM_CEXT_XSCALE, 0xfc100100, 0xfe500f00, "wldrw\t%12-15G, %A"},
151 {ARM_CEXT_XSCALE, 0x0c100000, 0x0e100e00, "wldr%L%c\t%12-15g, %l"},
152 {ARM_CEXT_XSCALE, 0x0e400100, 0x0fc00ff0, "wmac%21?su%20'z%c\t%12-15g, %16-19g, %0-3g"},
153 {ARM_CEXT_XSCALE, 0x0e800100, 0x0fc00ff0, "wmadd%21?su%20'x%c\t%12-15g, %16-19g, %0-3g"},
154 {ARM_CEXT_XSCALE, 0x0ec00100, 0x0fd00ff0, "wmadd%21?sun%c\t%12-15g, %16-19g, %0-3g"},
155 {ARM_CEXT_XSCALE, 0x0e000160, 0x0f100ff0, "wmax%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
156 {ARM_CEXT_XSCALE, 0x0e000080, 0x0f100fe0, "wmerge%c\t%12-15g, %16-19g, %0-3g, #%21-23d"},
157 {ARM_CEXT_XSCALE, 0x0e0000a0, 0x0f800ff0, "wmia%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
158 {ARM_CEXT_XSCALE, 0x0e800120, 0x0f800ff0, "wmiaw%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
159 {ARM_CEXT_XSCALE, 0x0e100160, 0x0f100ff0, "wmin%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
160 {ARM_CEXT_XSCALE, 0x0e000100, 0x0fc00ff0, "wmul%21?su%20?ml%23'r%c\t%12-15g, %16-19g, %0-3g"},
161 {ARM_CEXT_XSCALE, 0x0ed00100, 0x0fd00ff0, "wmul%21?sumr%c\t%12-15g, %16-19g, %0-3g"},
162 {ARM_CEXT_XSCALE, 0x0ee000c0, 0x0fe00ff0, "wmulwsm%20`r%c\t%12-15g, %16-19g, %0-3g"},
163 {ARM_CEXT_XSCALE, 0x0ec000c0, 0x0fe00ff0, "wmulwum%20`r%c\t%12-15g, %16-19g, %0-3g"},
164 {ARM_CEXT_XSCALE, 0x0eb000c0, 0x0ff00ff0, "wmulwl%c\t%12-15g, %16-19g, %0-3g"},
165 {ARM_CEXT_XSCALE, 0x0e8000a0, 0x0f800ff0, "wqmia%21?tb%20?tb%22'n%c\t%12-15g, %16-19g, %0-3g"},
166 {ARM_CEXT_XSCALE, 0x0e100080, 0x0fd00ff0, "wqmulm%21'r%c\t%12-15g, %16-19g, %0-3g"},
167 {ARM_CEXT_XSCALE, 0x0ec000e0, 0x0fd00ff0, "wqmulwm%21'r%c\t%12-15g, %16-19g, %0-3g"},
168 {ARM_CEXT_XSCALE, 0x0e000000, 0x0ff00ff0, "wor%c\t%12-15g, %16-19g, %0-3g"},
169 {ARM_CEXT_XSCALE, 0x0e000080, 0x0f000ff0, "wpack%20-23w%c\t%12-15g, %16-19g, %0-3g"},
170 {ARM_CEXT_XSCALE, 0xfe300040, 0xff300ef0, "wror%22-23w\t%12-15g, %16-19g, #%i"},
171 {ARM_CEXT_XSCALE, 0x0e300040, 0x0f300ff0, "wror%22-23w%c\t%12-15g, %16-19g, %0-3g"},
172 {ARM_CEXT_XSCALE, 0x0e300140, 0x0f300ff0, "wror%22-23wg%c\t%12-15g, %16-19g, %0-3G"},
173 {ARM_CEXT_XSCALE, 0x0e000120, 0x0fa00ff0, "wsad%22?hb%20'z%c\t%12-15g, %16-19g, %0-3g"},
174 {ARM_CEXT_XSCALE, 0x0e0001e0, 0x0f000ff0, "wshufh%c\t%12-15g, %16-19g, #%Z"},
175 {ARM_CEXT_XSCALE, 0xfe100040, 0xff300ef0, "wsll%22-23w\t%12-15g, %16-19g, #%i"},
176 {ARM_CEXT_XSCALE, 0x0e100040, 0x0f300ff0, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
177 {ARM_CEXT_XSCALE, 0x0e100148, 0x0f300ffc, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
178 {ARM_CEXT_XSCALE, 0xfe000040, 0xff300ef0, "wsra%22-23w\t%12-15g, %16-19g, #%i"},
179 {ARM_CEXT_XSCALE, 0x0e000040, 0x0f300ff0, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
180 {ARM_CEXT_XSCALE, 0x0e000148, 0x0f300ffc, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
181 {ARM_CEXT_XSCALE, 0xfe200040, 0xff300ef0, "wsrl%22-23w\t%12-15g, %16-19g, #%i"},
182 {ARM_CEXT_XSCALE, 0x0e200040, 0x0f300ff0, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
183 {ARM_CEXT_XSCALE, 0x0e200148, 0x0f300ffc, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
184 {ARM_CEXT_XSCALE, 0xfc400100, 0xfe500f00, "wstrd\t%12-15g, %r"},
185 {ARM_CEXT_XSCALE, 0xfc000100, 0xfe500f00, "wstrw\t%12-15G, %A"},
186 {ARM_CEXT_XSCALE, 0x0c000000, 0x0e100e00, "wstr%L%c\t%12-15g, %l"},
187 {ARM_CEXT_XSCALE, 0x0e0001a0, 0x0f000ff0, "wsub%20-23w%c\t%12-15g, %16-19g, %0-3g"},
188 {ARM_CEXT_XSCALE, 0x0ed001c0, 0x0ff00ff0, "wsubaddhx%c\t%12-15g, %16-19g, %0-3g"},
189 {ARM_CEXT_XSCALE, 0x0e1001c0, 0x0f300ff0, "wabsdiff%22-23w%c\t%12-15g, %16-19g, %0-3g"},
190 {ARM_CEXT_XSCALE, 0x0e0000c0, 0x0fd00fff, "wunpckeh%21?sub%c\t%12-15g, %16-19g"},
191 {ARM_CEXT_XSCALE, 0x0e4000c0, 0x0fd00fff, "wunpckeh%21?suh%c\t%12-15g, %16-19g"},
192 {ARM_CEXT_XSCALE, 0x0e8000c0, 0x0fd00fff, "wunpckeh%21?suw%c\t%12-15g, %16-19g"},
193 {ARM_CEXT_XSCALE, 0x0e0000e0, 0x0f100fff, "wunpckel%21?su%22-23w%c\t%12-15g, %16-19g"},
194 {ARM_CEXT_XSCALE, 0x0e1000c0, 0x0f300ff0, "wunpckih%22-23w%c\t%12-15g, %16-19g, %0-3g"},
195 {ARM_CEXT_XSCALE, 0x0e1000e0, 0x0f300ff0, "wunpckil%22-23w%c\t%12-15g, %16-19g, %0-3g"},
196 {ARM_CEXT_XSCALE, 0x0e100000, 0x0ff00ff0, "wxor%c\t%12-15g, %16-19g, %0-3g"},
197
198 /* Floating point coprocessor (FPA) instructions */
199 {FPU_FPA_EXT_V1, 0x0e000100, 0x0ff08f10, "adf%c%P%R\t%12-14f, %16-18f, %0-3f"},
200 {FPU_FPA_EXT_V1, 0x0e100100, 0x0ff08f10, "muf%c%P%R\t%12-14f, %16-18f, %0-3f"},
201 {FPU_FPA_EXT_V1, 0x0e200100, 0x0ff08f10, "suf%c%P%R\t%12-14f, %16-18f, %0-3f"},
202 {FPU_FPA_EXT_V1, 0x0e300100, 0x0ff08f10, "rsf%c%P%R\t%12-14f, %16-18f, %0-3f"},
203 {FPU_FPA_EXT_V1, 0x0e400100, 0x0ff08f10, "dvf%c%P%R\t%12-14f, %16-18f, %0-3f"},
204 {FPU_FPA_EXT_V1, 0x0e500100, 0x0ff08f10, "rdf%c%P%R\t%12-14f, %16-18f, %0-3f"},
205 {FPU_FPA_EXT_V1, 0x0e600100, 0x0ff08f10, "pow%c%P%R\t%12-14f, %16-18f, %0-3f"},
206 {FPU_FPA_EXT_V1, 0x0e700100, 0x0ff08f10, "rpw%c%P%R\t%12-14f, %16-18f, %0-3f"},
207 {FPU_FPA_EXT_V1, 0x0e800100, 0x0ff08f10, "rmf%c%P%R\t%12-14f, %16-18f, %0-3f"},
208 {FPU_FPA_EXT_V1, 0x0e900100, 0x0ff08f10, "fml%c%P%R\t%12-14f, %16-18f, %0-3f"},
209 {FPU_FPA_EXT_V1, 0x0ea00100, 0x0ff08f10, "fdv%c%P%R\t%12-14f, %16-18f, %0-3f"},
210 {FPU_FPA_EXT_V1, 0x0eb00100, 0x0ff08f10, "frd%c%P%R\t%12-14f, %16-18f, %0-3f"},
211 {FPU_FPA_EXT_V1, 0x0ec00100, 0x0ff08f10, "pol%c%P%R\t%12-14f, %16-18f, %0-3f"},
212 {FPU_FPA_EXT_V1, 0x0e008100, 0x0ff08f10, "mvf%c%P%R\t%12-14f, %0-3f"},
213 {FPU_FPA_EXT_V1, 0x0e108100, 0x0ff08f10, "mnf%c%P%R\t%12-14f, %0-3f"},
214 {FPU_FPA_EXT_V1, 0x0e208100, 0x0ff08f10, "abs%c%P%R\t%12-14f, %0-3f"},
215 {FPU_FPA_EXT_V1, 0x0e308100, 0x0ff08f10, "rnd%c%P%R\t%12-14f, %0-3f"},
216 {FPU_FPA_EXT_V1, 0x0e408100, 0x0ff08f10, "sqt%c%P%R\t%12-14f, %0-3f"},
217 {FPU_FPA_EXT_V1, 0x0e508100, 0x0ff08f10, "log%c%P%R\t%12-14f, %0-3f"},
218 {FPU_FPA_EXT_V1, 0x0e608100, 0x0ff08f10, "lgn%c%P%R\t%12-14f, %0-3f"},
219 {FPU_FPA_EXT_V1, 0x0e708100, 0x0ff08f10, "exp%c%P%R\t%12-14f, %0-3f"},
220 {FPU_FPA_EXT_V1, 0x0e808100, 0x0ff08f10, "sin%c%P%R\t%12-14f, %0-3f"},
221 {FPU_FPA_EXT_V1, 0x0e908100, 0x0ff08f10, "cos%c%P%R\t%12-14f, %0-3f"},
222 {FPU_FPA_EXT_V1, 0x0ea08100, 0x0ff08f10, "tan%c%P%R\t%12-14f, %0-3f"},
223 {FPU_FPA_EXT_V1, 0x0eb08100, 0x0ff08f10, "asn%c%P%R\t%12-14f, %0-3f"},
224 {FPU_FPA_EXT_V1, 0x0ec08100, 0x0ff08f10, "acs%c%P%R\t%12-14f, %0-3f"},
225 {FPU_FPA_EXT_V1, 0x0ed08100, 0x0ff08f10, "atn%c%P%R\t%12-14f, %0-3f"},
226 {FPU_FPA_EXT_V1, 0x0ee08100, 0x0ff08f10, "urd%c%P%R\t%12-14f, %0-3f"},
227 {FPU_FPA_EXT_V1, 0x0ef08100, 0x0ff08f10, "nrm%c%P%R\t%12-14f, %0-3f"},
228 {FPU_FPA_EXT_V1, 0x0e000110, 0x0ff00f1f, "flt%c%P%R\t%16-18f, %12-15r"},
229 {FPU_FPA_EXT_V1, 0x0e100110, 0x0fff0f98, "fix%c%R\t%12-15r, %0-2f"},
230 {FPU_FPA_EXT_V1, 0x0e200110, 0x0fff0fff, "wfs%c\t%12-15r"},
231 {FPU_FPA_EXT_V1, 0x0e300110, 0x0fff0fff, "rfs%c\t%12-15r"},
232 {FPU_FPA_EXT_V1, 0x0e400110, 0x0fff0fff, "wfc%c\t%12-15r"},
233 {FPU_FPA_EXT_V1, 0x0e500110, 0x0fff0fff, "rfc%c\t%12-15r"},
234 {FPU_FPA_EXT_V1, 0x0e90f110, 0x0ff8fff0, "cmf%c\t%16-18f, %0-3f"},
235 {FPU_FPA_EXT_V1, 0x0eb0f110, 0x0ff8fff0, "cnf%c\t%16-18f, %0-3f"},
236 {FPU_FPA_EXT_V1, 0x0ed0f110, 0x0ff8fff0, "cmfe%c\t%16-18f, %0-3f"},
237 {FPU_FPA_EXT_V1, 0x0ef0f110, 0x0ff8fff0, "cnfe%c\t%16-18f, %0-3f"},
238 {FPU_FPA_EXT_V1, 0x0c000100, 0x0e100f00, "stf%c%Q\t%12-14f, %A"},
239 {FPU_FPA_EXT_V1, 0x0c100100, 0x0e100f00, "ldf%c%Q\t%12-14f, %A"},
240 {FPU_FPA_EXT_V2, 0x0c000200, 0x0e100f00, "sfm%c\t%12-14f, %F, %A"},
241 {FPU_FPA_EXT_V2, 0x0c100200, 0x0e100f00, "lfm%c\t%12-14f, %F, %A"},
242
243 /* Register load/store */
244 {FPU_NEON_EXT_V1, 0x0d200b00, 0x0fb00f01, "vstmdb%c\t%16-19r%21'!, %B"},
245 {FPU_NEON_EXT_V1, 0x0d300b00, 0x0fb00f01, "vldmdb%c\t%16-19r%21'!, %B"},
246 {FPU_NEON_EXT_V1, 0x0c800b00, 0x0f900f01, "vstmia%c\t%16-19r%21'!, %B"},
247 {FPU_NEON_EXT_V1, 0x0c900b00, 0x0f900f01, "vldmia%c\t%16-19r%21'!, %B"},
248 {FPU_NEON_EXT_V1, 0x0d000b00, 0x0f300f00, "vstr%c\t%12-15,22D, %C"},
249 {FPU_NEON_EXT_V1, 0x0d100b00, 0x0f300f00, "vldr%c\t%12-15,22D, %C"},
250
251 /* Data transfer between ARM and NEON registers */
252 {FPU_NEON_EXT_V1, 0x0e800b10, 0x0ff00f70, "vdup%c.32\t%16-19,7D, %12-15r"},
253 {FPU_NEON_EXT_V1, 0x0e800b30, 0x0ff00f70, "vdup%c.16\t%16-19,7D, %12-15r"},
254 {FPU_NEON_EXT_V1, 0x0ea00b10, 0x0ff00f70, "vdup%c.32\t%16-19,7Q, %12-15r"},
255 {FPU_NEON_EXT_V1, 0x0ea00b30, 0x0ff00f70, "vdup%c.16\t%16-19,7Q, %12-15r"},
256 {FPU_NEON_EXT_V1, 0x0ec00b10, 0x0ff00f70, "vdup%c.8\t%16-19,7D, %12-15r"},
257 {FPU_NEON_EXT_V1, 0x0ee00b10, 0x0ff00f70, "vdup%c.8\t%16-19,7Q, %12-15r"},
258 {FPU_NEON_EXT_V1, 0x0c400b10, 0x0ff00fd0, "vmov%c\t%0-3,5D, %12-15r, %16-19r"},
259 {FPU_NEON_EXT_V1, 0x0c500b10, 0x0ff00fd0, "vmov%c\t%12-15r, %16-19r, %0-3,5D"},
260 {FPU_NEON_EXT_V1, 0x0e000b10, 0x0fd00f70, "vmov%c.32\t%16-19,7D[%21d], %12-15r"},
261 {FPU_NEON_EXT_V1, 0x0e100b10, 0x0f500f70, "vmov%c.32\t%12-15r, %16-19,7D[%21d]"},
262 {FPU_NEON_EXT_V1, 0x0e000b30, 0x0fd00f30, "vmov%c.16\t%16-19,7D[%6,21d], %12-15r"},
263 {FPU_NEON_EXT_V1, 0x0e100b30, 0x0f500f30, "vmov%c.%23?us16\t%12-15r, %16-19,7D[%6,21d]"},
264 {FPU_NEON_EXT_V1, 0x0e400b10, 0x0fd00f10, "vmov%c.8\t%16-19,7D[%5,6,21d], %12-15r"},
265 {FPU_NEON_EXT_V1, 0x0e500b10, 0x0f500f10, "vmov%c.%23?us8\t%12-15r, %16-19,7D[%5,6,21d]"},
266
267 /* Floating point coprocessor (VFP) instructions */
268 {FPU_VFP_EXT_V1xD, 0x0ef1fa10, 0x0fffffff, "fmstat%c"},
269 {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0fff0fff, "fmxr%c\tfpsid, %12-15r"},
270 {FPU_VFP_EXT_V1xD, 0x0ee10a10, 0x0fff0fff, "fmxr%c\tfpscr, %12-15r"},
271 {FPU_VFP_EXT_V1xD, 0x0ee60a10, 0x0fff0fff, "fmxr%c\tmvfr1, %12-15r"},
272 {FPU_VFP_EXT_V1xD, 0x0ee70a10, 0x0fff0fff, "fmxr%c\tmvfr0, %12-15r"},
273 {FPU_VFP_EXT_V1xD, 0x0ee80a10, 0x0fff0fff, "fmxr%c\tfpexc, %12-15r"},
274 {FPU_VFP_EXT_V1xD, 0x0ee90a10, 0x0fff0fff, "fmxr%c\tfpinst, %12-15r\t@ Impl def"},
275 {FPU_VFP_EXT_V1xD, 0x0eea0a10, 0x0fff0fff, "fmxr%c\tfpinst2, %12-15r\t@ Impl def"},
276 {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpsid"},
277 {FPU_VFP_EXT_V1xD, 0x0ef10a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpscr"},
278 {FPU_VFP_EXT_V1xD, 0x0ef60a10, 0x0fff0fff, "fmrx%c\t%12-15r, mvfr1"},
279 {FPU_VFP_EXT_V1xD, 0x0ef70a10, 0x0fff0fff, "fmrx%c\t%12-15r, mvfr0"},
280 {FPU_VFP_EXT_V1xD, 0x0ef80a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpexc"},
281 {FPU_VFP_EXT_V1xD, 0x0ef90a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst\t@ Impl def"},
282 {FPU_VFP_EXT_V1xD, 0x0efa0a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst2\t@ Impl def"},
283 {FPU_VFP_EXT_V1, 0x0e000b10, 0x0ff00fff, "fmdlr%c\t%z2, %12-15r"},
284 {FPU_VFP_EXT_V1, 0x0e100b10, 0x0ff00fff, "fmrdl%c\t%12-15r, %z2"},
285 {FPU_VFP_EXT_V1, 0x0e200b10, 0x0ff00fff, "fmdhr%c\t%z2, %12-15r"},
286 {FPU_VFP_EXT_V1, 0x0e300b10, 0x0ff00fff, "fmrdh%c\t%12-15r, %z2"},
287 {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0ff00fff, "fmxr%c\t<impl def %16-19x>, %12-15r"},
288 {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0ff00fff, "fmrx%c\t%12-15r, <impl def %16-19x>"},
289 {FPU_VFP_EXT_V1xD, 0x0e000a10, 0x0ff00f7f, "fmsr%c\t%y2, %12-15r"},
290 {FPU_VFP_EXT_V1xD, 0x0e100a10, 0x0ff00f7f, "fmrs%c\t%12-15r, %y2"},
291 {FPU_VFP_EXT_V1xD, 0x0eb50a40, 0x0fbf0f70, "fcmp%7'ezs%c\t%y1"},
292 {FPU_VFP_EXT_V1, 0x0eb50b40, 0x0fbf0f70, "fcmp%7'ezd%c\t%z1"},
293 {FPU_VFP_EXT_V1xD, 0x0eb00a40, 0x0fbf0fd0, "fcpys%c\t%y1, %y0"},
294 {FPU_VFP_EXT_V1xD, 0x0eb00ac0, 0x0fbf0fd0, "fabss%c\t%y1, %y0"},
295 {FPU_VFP_EXT_V1, 0x0eb00b40, 0x0fbf0fd0, "fcpyd%c\t%z1, %z0"},
296 {FPU_VFP_EXT_V1, 0x0eb00bc0, 0x0fbf0fd0, "fabsd%c\t%z1, %z0"},
297 {FPU_VFP_EXT_V1xD, 0x0eb10a40, 0x0fbf0fd0, "fnegs%c\t%y1, %y0"},
298 {FPU_VFP_EXT_V1xD, 0x0eb10ac0, 0x0fbf0fd0, "fsqrts%c\t%y1, %y0"},
299 {FPU_VFP_EXT_V1, 0x0eb10b40, 0x0fbf0fd0, "fnegd%c\t%z1, %z0"},
300 {FPU_VFP_EXT_V1, 0x0eb10bc0, 0x0fbf0fd0, "fsqrtd%c\t%z1, %z0"},
301 {FPU_VFP_EXT_V1, 0x0eb70ac0, 0x0fbf0fd0, "fcvtds%c\t%z1, %y0"},
302 {FPU_VFP_EXT_V1, 0x0eb70bc0, 0x0fbf0fd0, "fcvtsd%c\t%y1, %z0"},
303 {FPU_VFP_EXT_V1xD, 0x0eb80a40, 0x0fbf0fd0, "fuitos%c\t%y1, %y0"},
304 {FPU_VFP_EXT_V1xD, 0x0eb80ac0, 0x0fbf0fd0, "fsitos%c\t%y1, %y0"},
305 {FPU_VFP_EXT_V1, 0x0eb80b40, 0x0fbf0fd0, "fuitod%c\t%z1, %y0"},
306 {FPU_VFP_EXT_V1, 0x0eb80bc0, 0x0fbf0fd0, "fsitod%c\t%z1, %y0"},
307 {FPU_VFP_EXT_V1xD, 0x0eb40a40, 0x0fbf0f50, "fcmp%7'es%c\t%y1, %y0"},
308 {FPU_VFP_EXT_V1, 0x0eb40b40, 0x0fbf0f50, "fcmp%7'ed%c\t%z1, %z0"},
309 {FPU_VFP_EXT_V3, 0x0eba0a40, 0x0fbe0f50, "f%16?us%7?lhtos%c\t%y1, #%5,0-3k"},
310 {FPU_VFP_EXT_V3, 0x0eba0b40, 0x0fbe0f50, "f%16?us%7?lhtod%c\t%z1, #%5,0-3k"},
311 {FPU_VFP_EXT_V1xD, 0x0ebc0a40, 0x0fbe0f50, "fto%16?sui%7'zs%c\t%y1, %y0"},
312 {FPU_VFP_EXT_V1, 0x0ebc0b40, 0x0fbe0f50, "fto%16?sui%7'zd%c\t%y1, %z0"},
313 {FPU_VFP_EXT_V3, 0x0ebe0a40, 0x0fbe0f50, "fto%16?us%7?lhs%c\t%y1, #%5,0-3k"},
314 {FPU_VFP_EXT_V3, 0x0ebe0b40, 0x0fbe0f50, "fto%16?us%7?lhd%c\t%z1, #%5,0-3k"},
315 {FPU_VFP_EXT_V1, 0x0c500b10, 0x0fb00ff0, "fmrrd%c\t%12-15r, %16-19r, %z0"},
316 {FPU_VFP_EXT_V3, 0x0eb00a00, 0x0fb00ff0, "fconsts%c\t%y1, #%0-3,16-19d"},
317 {FPU_VFP_EXT_V3, 0x0eb00b00, 0x0fb00ff0, "fconstd%c\t%z1, #%0-3,16-19d"},
318 {FPU_VFP_EXT_V2, 0x0c400a10, 0x0ff00fd0, "fmsrr%c\t%y4, %12-15r, %16-19r"},
319 {FPU_VFP_EXT_V2, 0x0c400b10, 0x0ff00fd0, "fmdrr%c\t%z0, %12-15r, %16-19r"},
320 {FPU_VFP_EXT_V2, 0x0c500a10, 0x0ff00fd0, "fmrrs%c\t%12-15r, %16-19r, %y4"},
321 {FPU_VFP_EXT_V1xD, 0x0e000a00, 0x0fb00f50, "fmacs%c\t%y1, %y2, %y0"},
322 {FPU_VFP_EXT_V1xD, 0x0e000a40, 0x0fb00f50, "fnmacs%c\t%y1, %y2, %y0"},
323 {FPU_VFP_EXT_V1, 0x0e000b00, 0x0fb00f50, "fmacd%c\t%z1, %z2, %z0"},
324 {FPU_VFP_EXT_V1, 0x0e000b40, 0x0fb00f50, "fnmacd%c\t%z1, %z2, %z0"},
325 {FPU_VFP_EXT_V1xD, 0x0e100a00, 0x0fb00f50, "fmscs%c\t%y1, %y2, %y0"},
326 {FPU_VFP_EXT_V1xD, 0x0e100a40, 0x0fb00f50, "fnmscs%c\t%y1, %y2, %y0"},
327 {FPU_VFP_EXT_V1, 0x0e100b00, 0x0fb00f50, "fmscd%c\t%z1, %z2, %z0"},
328 {FPU_VFP_EXT_V1, 0x0e100b40, 0x0fb00f50, "fnmscd%c\t%z1, %z2, %z0"},
329 {FPU_VFP_EXT_V1xD, 0x0e200a00, 0x0fb00f50, "fmuls%c\t%y1, %y2, %y0"},
330 {FPU_VFP_EXT_V1xD, 0x0e200a40, 0x0fb00f50, "fnmuls%c\t%y1, %y2, %y0"},
331 {FPU_VFP_EXT_V1, 0x0e200b00, 0x0fb00f50, "fmuld%c\t%z1, %z2, %z0"},
332 {FPU_VFP_EXT_V1, 0x0e200b40, 0x0fb00f50, "fnmuld%c\t%z1, %z2, %z0"},
333 {FPU_VFP_EXT_V1xD, 0x0e300a00, 0x0fb00f50, "fadds%c\t%y1, %y2, %y0"},
334 {FPU_VFP_EXT_V1xD, 0x0e300a40, 0x0fb00f50, "fsubs%c\t%y1, %y2, %y0"},
335 {FPU_VFP_EXT_V1, 0x0e300b00, 0x0fb00f50, "faddd%c\t%z1, %z2, %z0"},
336 {FPU_VFP_EXT_V1, 0x0e300b40, 0x0fb00f50, "fsubd%c\t%z1, %z2, %z0"},
337 {FPU_VFP_EXT_V1xD, 0x0e800a00, 0x0fb00f50, "fdivs%c\t%y1, %y2, %y0"},
338 {FPU_VFP_EXT_V1, 0x0e800b00, 0x0fb00f50, "fdivd%c\t%z1, %z2, %z0"},
339 {FPU_VFP_EXT_V1xD, 0x0d200a00, 0x0fb00f00, "fstmdbs%c\t%16-19r!, %y3"},
340 {FPU_VFP_EXT_V1xD, 0x0d200b00, 0x0fb00f00, "fstmdb%0?xd%c\t%16-19r!, %z3"},
341 {FPU_VFP_EXT_V1xD, 0x0d300a00, 0x0fb00f00, "fldmdbs%c\t%16-19r!, %y3"},
342 {FPU_VFP_EXT_V1xD, 0x0d300b00, 0x0fb00f00, "fldmdb%0?xd%c\t%16-19r!, %z3"},
343 {FPU_VFP_EXT_V1xD, 0x0d000a00, 0x0f300f00, "fsts%c\t%y1, %A"},
344 {FPU_VFP_EXT_V1, 0x0d000b00, 0x0f300f00, "fstd%c\t%z1, %A"},
345 {FPU_VFP_EXT_V1xD, 0x0d100a00, 0x0f300f00, "flds%c\t%y1, %A"},
346 {FPU_VFP_EXT_V1, 0x0d100b00, 0x0f300f00, "fldd%c\t%z1, %A"},
347 {FPU_VFP_EXT_V1xD, 0x0c800a00, 0x0f900f00, "fstmias%c\t%16-19r%21'!, %y3"},
348 {FPU_VFP_EXT_V1xD, 0x0c800b00, 0x0f900f00, "fstmia%0?xd%c\t%16-19r%21'!, %z3"},
349 {FPU_VFP_EXT_V1xD, 0x0c900a00, 0x0f900f00, "fldmias%c\t%16-19r%21'!, %y3"},
350 {FPU_VFP_EXT_V1xD, 0x0c900b00, 0x0f900f00, "fldmia%0?xd%c\t%16-19r%21'!, %z3"},
351
352 /* Cirrus coprocessor instructions. */
353 {ARM_CEXT_MAVERICK, 0x0d100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
354 {ARM_CEXT_MAVERICK, 0x0c100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
355 {ARM_CEXT_MAVERICK, 0x0d500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
356 {ARM_CEXT_MAVERICK, 0x0c500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
357 {ARM_CEXT_MAVERICK, 0x0d100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
358 {ARM_CEXT_MAVERICK, 0x0c100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
359 {ARM_CEXT_MAVERICK, 0x0d500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
360 {ARM_CEXT_MAVERICK, 0x0c500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
361 {ARM_CEXT_MAVERICK, 0x0d000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
362 {ARM_CEXT_MAVERICK, 0x0c000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
363 {ARM_CEXT_MAVERICK, 0x0d400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
364 {ARM_CEXT_MAVERICK, 0x0c400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
365 {ARM_CEXT_MAVERICK, 0x0d000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
366 {ARM_CEXT_MAVERICK, 0x0c000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
367 {ARM_CEXT_MAVERICK, 0x0d400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
368 {ARM_CEXT_MAVERICK, 0x0c400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
369 {ARM_CEXT_MAVERICK, 0x0e000450, 0x0ff00ff0, "cfmvsr%c\tmvf%16-19d, %12-15r"},
370 {ARM_CEXT_MAVERICK, 0x0e100450, 0x0ff00ff0, "cfmvrs%c\t%12-15r, mvf%16-19d"},
371 {ARM_CEXT_MAVERICK, 0x0e000410, 0x0ff00ff0, "cfmvdlr%c\tmvd%16-19d, %12-15r"},
372 {ARM_CEXT_MAVERICK, 0x0e100410, 0x0ff00ff0, "cfmvrdl%c\t%12-15r, mvd%16-19d"},
373 {ARM_CEXT_MAVERICK, 0x0e000430, 0x0ff00ff0, "cfmvdhr%c\tmvd%16-19d, %12-15r"},
374 {ARM_CEXT_MAVERICK, 0x0e100430, 0x0ff00fff, "cfmvrdh%c\t%12-15r, mvd%16-19d"},
375 {ARM_CEXT_MAVERICK, 0x0e000510, 0x0ff00fff, "cfmv64lr%c\tmvdx%16-19d, %12-15r"},
376 {ARM_CEXT_MAVERICK, 0x0e100510, 0x0ff00fff, "cfmvr64l%c\t%12-15r, mvdx%16-19d"},
377 {ARM_CEXT_MAVERICK, 0x0e000530, 0x0ff00fff, "cfmv64hr%c\tmvdx%16-19d, %12-15r"},
378 {ARM_CEXT_MAVERICK, 0x0e100530, 0x0ff00fff, "cfmvr64h%c\t%12-15r, mvdx%16-19d"},
379 {ARM_CEXT_MAVERICK, 0x0e200440, 0x0ff00fff, "cfmval32%c\tmvax%12-15d, mvfx%16-19d"},
380 {ARM_CEXT_MAVERICK, 0x0e100440, 0x0ff00fff, "cfmv32al%c\tmvfx%12-15d, mvax%16-19d"},
381 {ARM_CEXT_MAVERICK, 0x0e200460, 0x0ff00fff, "cfmvam32%c\tmvax%12-15d, mvfx%16-19d"},
382 {ARM_CEXT_MAVERICK, 0x0e100460, 0x0ff00fff, "cfmv32am%c\tmvfx%12-15d, mvax%16-19d"},
383 {ARM_CEXT_MAVERICK, 0x0e200480, 0x0ff00fff, "cfmvah32%c\tmvax%12-15d, mvfx%16-19d"},
384 {ARM_CEXT_MAVERICK, 0x0e100480, 0x0ff00fff, "cfmv32ah%c\tmvfx%12-15d, mvax%16-19d"},
385 {ARM_CEXT_MAVERICK, 0x0e2004a0, 0x0ff00fff, "cfmva32%c\tmvax%12-15d, mvfx%16-19d"},
386 {ARM_CEXT_MAVERICK, 0x0e1004a0, 0x0ff00fff, "cfmv32a%c\tmvfx%12-15d, mvax%16-19d"},
387 {ARM_CEXT_MAVERICK, 0x0e2004c0, 0x0ff00fff, "cfmva64%c\tmvax%12-15d, mvdx%16-19d"},
388 {ARM_CEXT_MAVERICK, 0x0e1004c0, 0x0ff00fff, "cfmv64a%c\tmvdx%12-15d, mvax%16-19d"},
389 {ARM_CEXT_MAVERICK, 0x0e2004e0, 0x0fff0fff, "cfmvsc32%c\tdspsc, mvdx%12-15d"},
390 {ARM_CEXT_MAVERICK, 0x0e1004e0, 0x0fff0fff, "cfmv32sc%c\tmvdx%12-15d, dspsc"},
391 {ARM_CEXT_MAVERICK, 0x0e000400, 0x0ff00fff, "cfcpys%c\tmvf%12-15d, mvf%16-19d"},
392 {ARM_CEXT_MAVERICK, 0x0e000420, 0x0ff00fff, "cfcpyd%c\tmvd%12-15d, mvd%16-19d"},
393 {ARM_CEXT_MAVERICK, 0x0e000460, 0x0ff00fff, "cfcvtsd%c\tmvd%12-15d, mvf%16-19d"},
394 {ARM_CEXT_MAVERICK, 0x0e000440, 0x0ff00fff, "cfcvtds%c\tmvf%12-15d, mvd%16-19d"},
395 {ARM_CEXT_MAVERICK, 0x0e000480, 0x0ff00fff, "cfcvt32s%c\tmvf%12-15d, mvfx%16-19d"},
396 {ARM_CEXT_MAVERICK, 0x0e0004a0, 0x0ff00fff, "cfcvt32d%c\tmvd%12-15d, mvfx%16-19d"},
397 {ARM_CEXT_MAVERICK, 0x0e0004c0, 0x0ff00fff, "cfcvt64s%c\tmvf%12-15d, mvdx%16-19d"},
398 {ARM_CEXT_MAVERICK, 0x0e0004e0, 0x0ff00fff, "cfcvt64d%c\tmvd%12-15d, mvdx%16-19d"},
399 {ARM_CEXT_MAVERICK, 0x0e100580, 0x0ff00fff, "cfcvts32%c\tmvfx%12-15d, mvf%16-19d"},
400 {ARM_CEXT_MAVERICK, 0x0e1005a0, 0x0ff00fff, "cfcvtd32%c\tmvfx%12-15d, mvd%16-19d"},
401 {ARM_CEXT_MAVERICK, 0x0e1005c0, 0x0ff00fff, "cftruncs32%c\tmvfx%12-15d, mvf%16-19d"},
402 {ARM_CEXT_MAVERICK, 0x0e1005e0, 0x0ff00fff, "cftruncd32%c\tmvfx%12-15d, mvd%16-19d"},
403 {ARM_CEXT_MAVERICK, 0x0e000550, 0x0ff00ff0, "cfrshl32%c\tmvfx%16-19d, mvfx%0-3d, %12-15r"},
404 {ARM_CEXT_MAVERICK, 0x0e000570, 0x0ff00ff0, "cfrshl64%c\tmvdx%16-19d, mvdx%0-3d, %12-15r"},
405 {ARM_CEXT_MAVERICK, 0x0e000500, 0x0ff00f10, "cfsh32%c\tmvfx%12-15d, mvfx%16-19d, #%I"},
406 {ARM_CEXT_MAVERICK, 0x0e200500, 0x0ff00f10, "cfsh64%c\tmvdx%12-15d, mvdx%16-19d, #%I"},
407 {ARM_CEXT_MAVERICK, 0x0e100490, 0x0ff00ff0, "cfcmps%c\t%12-15r, mvf%16-19d, mvf%0-3d"},
408 {ARM_CEXT_MAVERICK, 0x0e1004b0, 0x0ff00ff0, "cfcmpd%c\t%12-15r, mvd%16-19d, mvd%0-3d"},
409 {ARM_CEXT_MAVERICK, 0x0e100590, 0x0ff00ff0, "cfcmp32%c\t%12-15r, mvfx%16-19d, mvfx%0-3d"},
410 {ARM_CEXT_MAVERICK, 0x0e1005b0, 0x0ff00ff0, "cfcmp64%c\t%12-15r, mvdx%16-19d, mvdx%0-3d"},
411 {ARM_CEXT_MAVERICK, 0x0e300400, 0x0ff00fff, "cfabss%c\tmvf%12-15d, mvf%16-19d"},
412 {ARM_CEXT_MAVERICK, 0x0e300420, 0x0ff00fff, "cfabsd%c\tmvd%12-15d, mvd%16-19d"},
413 {ARM_CEXT_MAVERICK, 0x0e300440, 0x0ff00fff, "cfnegs%c\tmvf%12-15d, mvf%16-19d"},
414 {ARM_CEXT_MAVERICK, 0x0e300460, 0x0ff00fff, "cfnegd%c\tmvd%12-15d, mvd%16-19d"},
415 {ARM_CEXT_MAVERICK, 0x0e300480, 0x0ff00ff0, "cfadds%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
416 {ARM_CEXT_MAVERICK, 0x0e3004a0, 0x0ff00ff0, "cfaddd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
417 {ARM_CEXT_MAVERICK, 0x0e3004c0, 0x0ff00ff0, "cfsubs%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
418 {ARM_CEXT_MAVERICK, 0x0e3004e0, 0x0ff00ff0, "cfsubd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
419 {ARM_CEXT_MAVERICK, 0x0e100400, 0x0ff00ff0, "cfmuls%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
420 {ARM_CEXT_MAVERICK, 0x0e100420, 0x0ff00ff0, "cfmuld%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
421 {ARM_CEXT_MAVERICK, 0x0e300500, 0x0ff00fff, "cfabs32%c\tmvfx%12-15d, mvfx%16-19d"},
422 {ARM_CEXT_MAVERICK, 0x0e300520, 0x0ff00fff, "cfabs64%c\tmvdx%12-15d, mvdx%16-19d"},
423 {ARM_CEXT_MAVERICK, 0x0e300540, 0x0ff00fff, "cfneg32%c\tmvfx%12-15d, mvfx%16-19d"},
424 {ARM_CEXT_MAVERICK, 0x0e300560, 0x0ff00fff, "cfneg64%c\tmvdx%12-15d, mvdx%16-19d"},
425 {ARM_CEXT_MAVERICK, 0x0e300580, 0x0ff00ff0, "cfadd32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
426 {ARM_CEXT_MAVERICK, 0x0e3005a0, 0x0ff00ff0, "cfadd64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
427 {ARM_CEXT_MAVERICK, 0x0e3005c0, 0x0ff00ff0, "cfsub32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
428 {ARM_CEXT_MAVERICK, 0x0e3005e0, 0x0ff00ff0, "cfsub64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
429 {ARM_CEXT_MAVERICK, 0x0e100500, 0x0ff00ff0, "cfmul32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
430 {ARM_CEXT_MAVERICK, 0x0e100520, 0x0ff00ff0, "cfmul64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
431 {ARM_CEXT_MAVERICK, 0x0e100540, 0x0ff00ff0, "cfmac32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
432 {ARM_CEXT_MAVERICK, 0x0e100560, 0x0ff00ff0, "cfmsc32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
433 {ARM_CEXT_MAVERICK, 0x0e000600, 0x0ff00f10, "cfmadd32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
434 {ARM_CEXT_MAVERICK, 0x0e100600, 0x0ff00f10, "cfmsub32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
435 {ARM_CEXT_MAVERICK, 0x0e200600, 0x0ff00f10, "cfmadda32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
436 {ARM_CEXT_MAVERICK, 0x0e300600, 0x0ff00f10, "cfmsuba32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
437
438 /* Generic coprocessor instructions */
439 {ARM_EXT_V2, 0x0c400000, 0x0ff00000, "mcrr%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
440 {ARM_EXT_V2, 0x0c500000, 0x0ff00000, "mrrc%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
441 {ARM_EXT_V2, 0x0e000000, 0x0f000010, "cdp%c\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
442 {ARM_EXT_V2, 0x0e100010, 0x0f100010, "mrc%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
443 {ARM_EXT_V2, 0x0e000010, 0x0f100010, "mcr%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
444 {ARM_EXT_V2, 0x0c000000, 0x0e100000, "stc%22'l%c\t%8-11d, cr%12-15d, %A"},
445 {ARM_EXT_V2, 0x0c100000, 0x0e100000, "ldc%22'l%c\t%8-11d, cr%12-15d, %A"},
446
447 /* V6 coprocessor instructions */
448 {ARM_EXT_V6, 0xfc500000, 0xfff00000, "mrrc2%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
449 {ARM_EXT_V6, 0xfc400000, 0xfff00000, "mcrr2%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
450
451 /* V5 coprocessor instructions */
452 {ARM_EXT_V5, 0xfc100000, 0xfe100000, "ldc2%22'l%c\t%8-11d, cr%12-15d, %A"},
453 {ARM_EXT_V5, 0xfc000000, 0xfe100000, "stc2%22'l%c\t%8-11d, cr%12-15d, %A"},
454 {ARM_EXT_V5, 0xfe000000, 0xff000010, "cdp2%c\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
455 {ARM_EXT_V5, 0xfe000010, 0xff100010, "mcr2%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
456 {ARM_EXT_V5, 0xfe100010, 0xff100010, "mrc2%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
457
458 {0, 0, 0, 0}
459 };
460
461 /* Neon opcode table: This does not encode the top byte -- that is
462 checked by the print_insn_neon routine, as it depends on whether we are
463 doing thumb32 or arm32 disassembly. */
464
465 /* print_insn_neon recognizes the following format control codes:
466
467 %% %
468
469 %c print condition code
470 %A print v{st,ld}[1234] operands
471 %B print v{st,ld}[1234] any one operands
472 %C print v{st,ld}[1234] single->all operands
473 %D print scalar
474 %E print vmov, vmvn, vorr, vbic encoded constant
475 %F print vtbl,vtbx register list
476
477 %<bitfield>r print as an ARM register
478 %<bitfield>d print the bitfield in decimal
479 %<bitfield>e print the 2^N - bitfield in decimal
480 %<bitfield>D print as a NEON D register
481 %<bitfield>Q print as a NEON Q register
482 %<bitfield>R print as a NEON D or Q register
483 %<bitfield>Sn print byte scaled width limited by n
484 %<bitfield>Tn print short scaled width limited by n
485 %<bitfield>Un print long scaled width limited by n
486
487 %<bitfield>'c print specified char iff bitfield is all ones
488 %<bitfield>`c print specified char iff bitfield is all zeroes
489 %<bitfield>?ab... select from array of values in big endian order */
490
491 static const struct opcode32 neon_opcodes[] =
492 {
493 /* Extract */
494 {FPU_NEON_EXT_V1, 0xf2b00840, 0xffb00850, "vext%c.8\t%12-15,22R, %16-19,7R, %0-3,5R, #%8-11d"},
495 {FPU_NEON_EXT_V1, 0xf2b00000, 0xffb00810, "vext%c.8\t%12-15,22R, %16-19,7R, %0-3,5R, #%8-11d"},
496
497 /* Move data element to all lanes */
498 {FPU_NEON_EXT_V1, 0xf3b40c00, 0xffb70f90, "vdup%c.32\t%12-15,22R, %0-3,5D[%19d]"},
499 {FPU_NEON_EXT_V1, 0xf3b20c00, 0xffb30f90, "vdup%c.16\t%12-15,22R, %0-3,5D[%18-19d]"},
500 {FPU_NEON_EXT_V1, 0xf3b10c00, 0xffb10f90, "vdup%c.8\t%12-15,22R, %0-3,5D[%17-19d]"},
501
502 /* Table lookup */
503 {FPU_NEON_EXT_V1, 0xf3b00800, 0xffb00c50, "vtbl%c.8\t%12-15,22D, %F, %0-3,5D"},
504 {FPU_NEON_EXT_V1, 0xf3b00840, 0xffb00c50, "vtbx%c.8\t%12-15,22D, %F, %0-3,5D"},
505
506 /* Two registers, miscellaneous */
507 {FPU_NEON_EXT_V1, 0xf2880a10, 0xfebf0fd0, "vmovl%c.%24?us8\t%12-15,22Q, %0-3,5D"},
508 {FPU_NEON_EXT_V1, 0xf2900a10, 0xfebf0fd0, "vmovl%c.%24?us16\t%12-15,22Q, %0-3,5D"},
509 {FPU_NEON_EXT_V1, 0xf2a00a10, 0xfebf0fd0, "vmovl%c.%24?us32\t%12-15,22Q, %0-3,5D"},
510 {FPU_NEON_EXT_V1, 0xf3b00500, 0xffbf0f90, "vcnt%c.8\t%12-15,22R, %0-3,5R"},
511 {FPU_NEON_EXT_V1, 0xf3b00580, 0xffbf0f90, "vmvn%c\t%12-15,22R, %0-3,5R"},
512 {FPU_NEON_EXT_V1, 0xf3b20000, 0xffbf0f90, "vswp%c\t%12-15,22R, %0-3,5R"},
513 {FPU_NEON_EXT_V1, 0xf3b20200, 0xffb30fd0, "vmovn%c.i%18-19T2\t%12-15,22D, %0-3,5Q"},
514 {FPU_NEON_EXT_V1, 0xf3b20240, 0xffb30fd0, "vqmovun%c.s%18-19T2\t%12-15,22D, %0-3,5Q"},
515 {FPU_NEON_EXT_V1, 0xf3b20280, 0xffb30fd0, "vqmovn%c.s%18-19T2\t%12-15,22D, %0-3,5Q"},
516 {FPU_NEON_EXT_V1, 0xf3b202c0, 0xffb30fd0, "vqmovn%c.u%18-19T2\t%12-15,22D, %0-3,5Q"},
517 {FPU_NEON_EXT_V1, 0xf3b20300, 0xffb30fd0, "vshll%c.i%18-19S2\t%12-15,22Q, %0-3,5D, #%18-19S2"},
518 {FPU_NEON_EXT_V1, 0xf3bb0400, 0xffbf0e90, "vrecpe%c.%8?fu%18-19S2\t%12-15,22R, %0-3,5R"},
519 {FPU_NEON_EXT_V1, 0xf3bb0480, 0xffbf0e90, "vrsqrte%c.%8?fu%18-19S2\t%12-15,22R, %0-3,5R"},
520 {FPU_NEON_EXT_V1, 0xf3b00000, 0xffb30f90, "vrev64%c.%18-19S2\t%12-15,22R, %0-3,5R"},
521 {FPU_NEON_EXT_V1, 0xf3b00080, 0xffb30f90, "vrev32%c.%18-19S2\t%12-15,22R, %0-3,5R"},
522 {FPU_NEON_EXT_V1, 0xf3b00100, 0xffb30f90, "vrev16%c.%18-19S2\t%12-15,22R, %0-3,5R"},
523 {FPU_NEON_EXT_V1, 0xf3b00400, 0xffb30f90, "vcls%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
524 {FPU_NEON_EXT_V1, 0xf3b00480, 0xffb30f90, "vclz%c.i%18-19S2\t%12-15,22R, %0-3,5R"},
525 {FPU_NEON_EXT_V1, 0xf3b00700, 0xffb30f90, "vqabs%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
526 {FPU_NEON_EXT_V1, 0xf3b00780, 0xffb30f90, "vqneg%c.s%18-19S2\t%12-15,22R, %0-3,5R"},
527 {FPU_NEON_EXT_V1, 0xf3b20080, 0xffb30f90, "vtrn%c.%18-19S2\t%12-15,22R, %0-3,5R"},
528 {FPU_NEON_EXT_V1, 0xf3b20100, 0xffb30f90, "vuzp%c.%18-19S2\t%12-15,22R, %0-3,5R"},
529 {FPU_NEON_EXT_V1, 0xf3b20180, 0xffb30f90, "vzip%c.%18-19S2\t%12-15,22R, %0-3,5R"},
530 {FPU_NEON_EXT_V1, 0xf3b10000, 0xffb30b90, "vcgt%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
531 {FPU_NEON_EXT_V1, 0xf3b10080, 0xffb30b90, "vcge%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
532 {FPU_NEON_EXT_V1, 0xf3b10100, 0xffb30b90, "vceq%c.%10?fi%18-19S2\t%12-15,22R, %0-3,5R, #0"},
533 {FPU_NEON_EXT_V1, 0xf3b10180, 0xffb30b90, "vcle%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
534 {FPU_NEON_EXT_V1, 0xf3b10200, 0xffb30b90, "vclt%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R, #0"},
535 {FPU_NEON_EXT_V1, 0xf3b10300, 0xffb30b90, "vabs%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R"},
536 {FPU_NEON_EXT_V1, 0xf3b10380, 0xffb30b90, "vneg%c.%10?fs%18-19S2\t%12-15,22R, %0-3,5R"},
537 {FPU_NEON_EXT_V1, 0xf3b00200, 0xffb30f10, "vpaddl%c.%7?us%18-19S2\t%12-15,22R, %0-3,5R"},
538 {FPU_NEON_EXT_V1, 0xf3b00600, 0xffb30f10, "vpadal%c.%7?us%18-19S2\t%12-15,22R, %0-3,5R"},
539 {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"},
540
541 /* Three registers of the same length */
542 {FPU_NEON_EXT_V1, 0xf2000110, 0xffb00f10, "vand%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
543 {FPU_NEON_EXT_V1, 0xf2100110, 0xffb00f10, "vbic%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
544 {FPU_NEON_EXT_V1, 0xf2200110, 0xffb00f10, "vorr%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
545 {FPU_NEON_EXT_V1, 0xf2300110, 0xffb00f10, "vorn%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
546 {FPU_NEON_EXT_V1, 0xf3000110, 0xffb00f10, "veor%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
547 {FPU_NEON_EXT_V1, 0xf3100110, 0xffb00f10, "vbsl%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
548 {FPU_NEON_EXT_V1, 0xf3200110, 0xffb00f10, "vbit%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
549 {FPU_NEON_EXT_V1, 0xf3300110, 0xffb00f10, "vbif%c\t%12-15,22R, %16-19,7R, %0-3,5R"},
550 {FPU_NEON_EXT_V1, 0xf2000d00, 0xffa00f10, "vadd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
551 {FPU_NEON_EXT_V1, 0xf2000d10, 0xffa00f10, "vmla%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
552 {FPU_NEON_EXT_V1, 0xf2000e00, 0xffa00f10, "vceq%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
553 {FPU_NEON_EXT_V1, 0xf2000f00, 0xffa00f10, "vmax%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
554 {FPU_NEON_EXT_V1, 0xf2000f10, 0xffa00f10, "vrecps%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
555 {FPU_NEON_EXT_V1, 0xf2200d00, 0xffa00f10, "vsub%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
556 {FPU_NEON_EXT_V1, 0xf2200d10, 0xffa00f10, "vmls%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
557 {FPU_NEON_EXT_V1, 0xf2200f00, 0xffa00f10, "vmin%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
558 {FPU_NEON_EXT_V1, 0xf2200f10, 0xffa00f10, "vrsqrts%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
559 {FPU_NEON_EXT_V1, 0xf3000d00, 0xffa00f10, "vpadd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
560 {FPU_NEON_EXT_V1, 0xf3000d10, 0xffa00f10, "vmul%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
561 {FPU_NEON_EXT_V1, 0xf3000e00, 0xffa00f10, "vcge%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
562 {FPU_NEON_EXT_V1, 0xf3000e10, 0xffa00f10, "vacge%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
563 {FPU_NEON_EXT_V1, 0xf3000f00, 0xffa00f10, "vpmax%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
564 {FPU_NEON_EXT_V1, 0xf3200d00, 0xffa00f10, "vabd%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
565 {FPU_NEON_EXT_V1, 0xf3200e00, 0xffa00f10, "vcgt%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
566 {FPU_NEON_EXT_V1, 0xf3200e10, 0xffa00f10, "vacgt%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
567 {FPU_NEON_EXT_V1, 0xf3200f00, 0xffa00f10, "vpmin%c.f%20U0\t%12-15,22R, %16-19,7R, %0-3,5R"},
568 {FPU_NEON_EXT_V1, 0xf2000800, 0xff800f10, "vadd%c.i%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
569 {FPU_NEON_EXT_V1, 0xf2000810, 0xff800f10, "vtst%c.%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
570 {FPU_NEON_EXT_V1, 0xf2000900, 0xff800f10, "vmla%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
571 {FPU_NEON_EXT_V1, 0xf2000b00, 0xff800f10, "vqdmulh%c.s%20-21S6\t%12-15,22R, %16-19,7R, %0-3,5R"},
572 {FPU_NEON_EXT_V1, 0xf2000b10, 0xff800f10, "vpadd%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
573 {FPU_NEON_EXT_V1, 0xf3000800, 0xff800f10, "vsub%c.i%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
574 {FPU_NEON_EXT_V1, 0xf3000810, 0xff800f10, "vceq%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
575 {FPU_NEON_EXT_V1, 0xf3000900, 0xff800f10, "vmls%c.i%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
576 {FPU_NEON_EXT_V1, 0xf3000b00, 0xff800f10, "vqrdmulh%c.s%20-21S6\t%12-15,22R, %16-19,7R, %0-3,5R"},
577 {FPU_NEON_EXT_V1, 0xf2000000, 0xfe800f10, "vhadd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
578 {FPU_NEON_EXT_V1, 0xf2000010, 0xfe800f10, "vqadd%c.%24?us%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
579 {FPU_NEON_EXT_V1, 0xf2000100, 0xfe800f10, "vrhadd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
580 {FPU_NEON_EXT_V1, 0xf2000200, 0xfe800f10, "vhsub%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
581 {FPU_NEON_EXT_V1, 0xf2000210, 0xfe800f10, "vqsub%c.%24?us%20-21S3\t%12-15,22R, %16-19,7R, %0-3,5R"},
582 {FPU_NEON_EXT_V1, 0xf2000300, 0xfe800f10, "vcgt%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
583 {FPU_NEON_EXT_V1, 0xf2000310, 0xfe800f10, "vcge%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
584 {FPU_NEON_EXT_V1, 0xf2000400, 0xfe800f10, "vshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
585 {FPU_NEON_EXT_V1, 0xf2000410, 0xfe800f10, "vqshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
586 {FPU_NEON_EXT_V1, 0xf2000500, 0xfe800f10, "vrshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
587 {FPU_NEON_EXT_V1, 0xf2000510, 0xfe800f10, "vqrshl%c.%24?us%20-21S3\t%12-15,22R, %0-3,5R, %16-19,7R"},
588 {FPU_NEON_EXT_V1, 0xf2000600, 0xfe800f10, "vmax%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
589 {FPU_NEON_EXT_V1, 0xf2000610, 0xfe800f10, "vmin%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
590 {FPU_NEON_EXT_V1, 0xf2000700, 0xfe800f10, "vabd%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
591 {FPU_NEON_EXT_V1, 0xf2000710, 0xfe800f10, "vaba%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
592 {FPU_NEON_EXT_V1, 0xf2000910, 0xfe800f10, "vmul%c.%24?pi%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
593 {FPU_NEON_EXT_V1, 0xf2000a00, 0xfe800f10, "vpmax%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
594 {FPU_NEON_EXT_V1, 0xf2000a10, 0xfe800f10, "vpmin%c.%24?us%20-21S2\t%12-15,22R, %16-19,7R, %0-3,5R"},
595
596 /* One register and an immediate value */
597 {FPU_NEON_EXT_V1, 0xf2800e10, 0xfeb80fb0, "vmov%c.i8\t%12-15,22R, %E"},
598 {FPU_NEON_EXT_V1, 0xf2800e30, 0xfeb80fb0, "vmov%c.i64\t%12-15,22R, %E"},
599 {FPU_NEON_EXT_V1, 0xf2800f10, 0xfeb80fb0, "vmov%c.f32\t%12-15,22R, %E"},
600 {FPU_NEON_EXT_V1, 0xf2800810, 0xfeb80db0, "vmov%c.i16\t%12-15,22R, %E"},
601 {FPU_NEON_EXT_V1, 0xf2800830, 0xfeb80db0, "vmvn%c.i16\t%12-15,22R, %E"},
602 {FPU_NEON_EXT_V1, 0xf2800910, 0xfeb80db0, "vorr%c.i16\t%12-15,22R, %E"},
603 {FPU_NEON_EXT_V1, 0xf2800930, 0xfeb80db0, "vbic%c.i16\t%12-15,22R, %E"},
604 {FPU_NEON_EXT_V1, 0xf2800c10, 0xfeb80eb0, "vmov%c.i32\t%12-15,22R, %E"},
605 {FPU_NEON_EXT_V1, 0xf2800c30, 0xfeb80eb0, "vmvn%c.i32\t%12-15,22R, %E"},
606 {FPU_NEON_EXT_V1, 0xf2800110, 0xfeb809b0, "vorr%c.i32\t%12-15,22R, %E"},
607 {FPU_NEON_EXT_V1, 0xf2800130, 0xfeb809b0, "vbic%c.i32\t%12-15,22R, %E"},
608 {FPU_NEON_EXT_V1, 0xf2800010, 0xfeb808b0, "vmov%c.i32\t%12-15,22R, %E"},
609 {FPU_NEON_EXT_V1, 0xf2800030, 0xfeb808b0, "vmvn%c.i32\t%12-15,22R, %E"},
610
611 /* Two registers and a shift amount */
612 {FPU_NEON_EXT_V1, 0xf2880810, 0xffb80fd0, "vshrn%c.i16\t%12-15,22D, %0-3,5Q, #%16-18e"},
613 {FPU_NEON_EXT_V1, 0xf2880850, 0xffb80fd0, "vrshrn%c.i16\t%12-15,22D, %0-3,5Q, #%16-18e"},
614 {FPU_NEON_EXT_V1, 0xf2880810, 0xfeb80fd0, "vqshrun%c.s16\t%12-15,22D, %0-3,5Q, #%16-18e"},
615 {FPU_NEON_EXT_V1, 0xf2880850, 0xfeb80fd0, "vqrshrun%c.s16\t%12-15,22D, %0-3,5Q, #%16-18e"},
616 {FPU_NEON_EXT_V1, 0xf2880910, 0xfeb80fd0, "vqshrn%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-18e"},
617 {FPU_NEON_EXT_V1, 0xf2880950, 0xfeb80fd0, "vqrshrn%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-18e"},
618 {FPU_NEON_EXT_V1, 0xf2880a10, 0xfeb80fd0, "vshll%c.%24?us8\t%12-15,22D, %0-3,5Q, #%16-18d"},
619 {FPU_NEON_EXT_V1, 0xf2900810, 0xffb00fd0, "vshrn%c.i32\t%12-15,22D, %0-3,5Q, #%16-19e"},
620 {FPU_NEON_EXT_V1, 0xf2900850, 0xffb00fd0, "vrshrn%c.i32\t%12-15,22D, %0-3,5Q, #%16-19e"},
621 {FPU_NEON_EXT_V1, 0xf2880510, 0xffb80f90, "vshl%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18d"},
622 {FPU_NEON_EXT_V1, 0xf3880410, 0xffb80f90, "vsri%c.8\t%12-15,22R, %0-3,5R, #%16-18e"},
623 {FPU_NEON_EXT_V1, 0xf3880510, 0xffb80f90, "vsli%c.8\t%12-15,22R, %0-3,5R, #%16-18d"},
624 {FPU_NEON_EXT_V1, 0xf3880610, 0xffb80f90, "vqshlu%c.s8\t%12-15,22R, %0-3,5R, #%16-18d"},
625 {FPU_NEON_EXT_V1, 0xf2900810, 0xfeb00fd0, "vqshrun%c.s32\t%12-15,22D, %0-3,5Q, #%16-19e"},
626 {FPU_NEON_EXT_V1, 0xf2900850, 0xfeb00fd0, "vqrshrun%c.s32\t%12-15,22D, %0-3,5Q, #%16-19e"},
627 {FPU_NEON_EXT_V1, 0xf2900910, 0xfeb00fd0, "vqshrn%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-19e"},
628 {FPU_NEON_EXT_V1, 0xf2900950, 0xfeb00fd0, "vqrshrn%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-19e"},
629 {FPU_NEON_EXT_V1, 0xf2900a10, 0xfeb00fd0, "vshll%c.%24?us16\t%12-15,22D, %0-3,5Q, #%16-19d"},
630 {FPU_NEON_EXT_V1, 0xf2880010, 0xfeb80f90, "vshr%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
631 {FPU_NEON_EXT_V1, 0xf2880110, 0xfeb80f90, "vsra%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
632 {FPU_NEON_EXT_V1, 0xf2880210, 0xfeb80f90, "vrshr%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
633 {FPU_NEON_EXT_V1, 0xf2880310, 0xfeb80f90, "vrsra%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18e"},
634 {FPU_NEON_EXT_V1, 0xf2880710, 0xfeb80f90, "vqshl%c.%24?us8\t%12-15,22R, %0-3,5R, #%16-18d"},
635 {FPU_NEON_EXT_V1, 0xf2a00810, 0xffa00fd0, "vshrn%c.i64\t%12-15,22D, %0-3,5Q, #%16-20e"},
636 {FPU_NEON_EXT_V1, 0xf2a00850, 0xffa00fd0, "vrshrn%c.i64\t%12-15,22D, %0-3,5Q, #%16-20e"},
637 {FPU_NEON_EXT_V1, 0xf2900510, 0xffb00f90, "vshl%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19d"},
638 {FPU_NEON_EXT_V1, 0xf3900410, 0xffb00f90, "vsri%c.16\t%12-15,22R, %0-3,5R, #%16-19e"},
639 {FPU_NEON_EXT_V1, 0xf3900510, 0xffb00f90, "vsli%c.16\t%12-15,22R, %0-3,5R, #%16-19d"},
640 {FPU_NEON_EXT_V1, 0xf3900610, 0xffb00f90, "vqshlu%c.s16\t%12-15,22R, %0-3,5R, #%16-19d"},
641 {FPU_NEON_EXT_V1, 0xf2a00a10, 0xfea00fd0, "vshll%c.%24?us32\t%12-15,22D, %0-3,5Q, #%16-20d"},
642 {FPU_NEON_EXT_V1, 0xf2900010, 0xfeb00f90, "vshr%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
643 {FPU_NEON_EXT_V1, 0xf2900110, 0xfeb00f90, "vsra%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
644 {FPU_NEON_EXT_V1, 0xf2900210, 0xfeb00f90, "vrshr%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
645 {FPU_NEON_EXT_V1, 0xf2900310, 0xfeb00f90, "vrsra%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19e"},
646 {FPU_NEON_EXT_V1, 0xf2900710, 0xfeb00f90, "vqshl%c.%24?us16\t%12-15,22R, %0-3,5R, #%16-19d"},
647 {FPU_NEON_EXT_V1, 0xf2800810, 0xfec00fd0, "vqshrun%c.s64\t%12-15,22D, %0-3,5Q, #%16-20e"},
648 {FPU_NEON_EXT_V1, 0xf2800850, 0xfec00fd0, "vqrshrun%c.s64\t%12-15,22D, %0-3,5Q, #%16-20e"},
649 {FPU_NEON_EXT_V1, 0xf2800910, 0xfec00fd0, "vqshrn%c.%24?us64\t%12-15,22D, %0-3,5Q, #%16-20e"},
650 {FPU_NEON_EXT_V1, 0xf2800950, 0xfec00fd0, "vqrshrn%c.%24?us64\t%12-15,22D, %0-3,5Q, #%16-20e"},
651 {FPU_NEON_EXT_V1, 0xf2a00510, 0xffa00f90, "vshl%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20d"},
652 {FPU_NEON_EXT_V1, 0xf3a00410, 0xffa00f90, "vsri%c.32\t%12-15,22R, %0-3,5R, #%16-20e"},
653 {FPU_NEON_EXT_V1, 0xf3a00510, 0xffa00f90, "vsli%c.32\t%12-15,22R, %0-3,5R, #%16-20d"},
654 {FPU_NEON_EXT_V1, 0xf3a00610, 0xffa00f90, "vqshlu%c.s32\t%12-15,22R, %0-3,5R, #%16-20d"},
655 {FPU_NEON_EXT_V1, 0xf2a00010, 0xfea00f90, "vshr%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
656 {FPU_NEON_EXT_V1, 0xf2a00110, 0xfea00f90, "vsra%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
657 {FPU_NEON_EXT_V1, 0xf2a00210, 0xfea00f90, "vrshr%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
658 {FPU_NEON_EXT_V1, 0xf2a00310, 0xfea00f90, "vrsra%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20e"},
659 {FPU_NEON_EXT_V1, 0xf2a00710, 0xfea00f90, "vqshl%c.%24?us32\t%12-15,22R, %0-3,5R, #%16-20d"},
660 {FPU_NEON_EXT_V1, 0xf2800590, 0xff800f90, "vshl%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21d"},
661 {FPU_NEON_EXT_V1, 0xf3800490, 0xff800f90, "vsri%c.64\t%12-15,22R, %0-3,5R, #%16-21e"},
662 {FPU_NEON_EXT_V1, 0xf3800590, 0xff800f90, "vsli%c.64\t%12-15,22R, %0-3,5R, #%16-21d"},
663 {FPU_NEON_EXT_V1, 0xf3800690, 0xff800f90, "vqshlu%c.s64\t%12-15,22R, %0-3,5R, #%16-21d"},
664 {FPU_NEON_EXT_V1, 0xf2800090, 0xfe800f90, "vshr%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
665 {FPU_NEON_EXT_V1, 0xf2800190, 0xfe800f90, "vsra%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
666 {FPU_NEON_EXT_V1, 0xf2800290, 0xfe800f90, "vrshr%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
667 {FPU_NEON_EXT_V1, 0xf2800390, 0xfe800f90, "vrsra%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21e"},
668 {FPU_NEON_EXT_V1, 0xf2800790, 0xfe800f90, "vqshl%c.%24?us64\t%12-15,22R, %0-3,5R, #%16-21d"},
669 {FPU_NEON_EXT_V1, 0xf2a00e10, 0xfea00e90, "vcvt%c.%24,8?usff32.%24,8?ffus32\t%12-15,22R, %0-3,5R, #%16-20e"},
670
671 /* Three registers of different lengths */
672 {FPU_NEON_EXT_V1, 0xf2800e00, 0xfea00f50, "vmull%c.p%20S0\t%12-15,22Q, %16-19,7D, %0-3,5D"},
673 {FPU_NEON_EXT_V1, 0xf2800400, 0xff800f50, "vaddhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
674 {FPU_NEON_EXT_V1, 0xf2800600, 0xff800f50, "vsubhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
675 {FPU_NEON_EXT_V1, 0xf2800900, 0xff800f50, "vqdmlal%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
676 {FPU_NEON_EXT_V1, 0xf2800b00, 0xff800f50, "vqdmlsl%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
677 {FPU_NEON_EXT_V1, 0xf2800d00, 0xff800f50, "vqdmull%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %0-3,5D"},
678 {FPU_NEON_EXT_V1, 0xf3800400, 0xff800f50, "vraddhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
679 {FPU_NEON_EXT_V1, 0xf3800600, 0xff800f50, "vrsubhn%c.i%20-21T2\t%12-15,22D, %16-19,7Q, %0-3,5Q"},
680 {FPU_NEON_EXT_V1, 0xf2800000, 0xfe800f50, "vaddl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
681 {FPU_NEON_EXT_V1, 0xf2800100, 0xfe800f50, "vaddw%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7Q, %0-3,5D"},
682 {FPU_NEON_EXT_V1, 0xf2800200, 0xfe800f50, "vsubl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
683 {FPU_NEON_EXT_V1, 0xf2800300, 0xfe800f50, "vsubw%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7Q, %0-3,5D"},
684 {FPU_NEON_EXT_V1, 0xf2800500, 0xfe800f50, "vabal%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
685 {FPU_NEON_EXT_V1, 0xf2800700, 0xfe800f50, "vabdl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
686 {FPU_NEON_EXT_V1, 0xf2800800, 0xfe800f50, "vmlal%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
687 {FPU_NEON_EXT_V1, 0xf2800a00, 0xfe800f50, "vmlsl%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
688 {FPU_NEON_EXT_V1, 0xf2800c00, 0xfe800f50, "vmull%c.%24?us%20-21S2\t%12-15,22Q, %16-19,7D, %0-3,5D"},
689
690 /* Two registers and a scalar */
691 {FPU_NEON_EXT_V1, 0xf2800040, 0xff800f50, "vmla%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
692 {FPU_NEON_EXT_V1, 0xf2800140, 0xff800f50, "vmla%c.f%20-21Sa\t%12-15,22D, %16-19,7D, %D"},
693 {FPU_NEON_EXT_V1, 0xf2800340, 0xff800f50, "vqdmlal%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
694 {FPU_NEON_EXT_V1, 0xf2800440, 0xff800f50, "vmls%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
695 {FPU_NEON_EXT_V1, 0xf2800540, 0xff800f50, "vmls%c.f%20-21S6\t%12-15,22D, %16-19,7D, %D"},
696 {FPU_NEON_EXT_V1, 0xf2800740, 0xff800f50, "vqdmlsl%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
697 {FPU_NEON_EXT_V1, 0xf2800840, 0xff800f50, "vmul%c.i%20-21S6\t%12-15,22D, %16-19,7D, %D"},
698 {FPU_NEON_EXT_V1, 0xf2800940, 0xff800f50, "vmul%c.f%20-21Sa\t%12-15,22D, %16-19,7D, %D"},
699 {FPU_NEON_EXT_V1, 0xf2800b40, 0xff800f50, "vqdmull%c.s%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
700 {FPU_NEON_EXT_V1, 0xf2800c40, 0xff800f50, "vqdmulh%c.s%20-21S6\t%12-15,22D, %16-19,7D, %D"},
701 {FPU_NEON_EXT_V1, 0xf2800d40, 0xff800f50, "vqrdmulh%c.s%20-21S6\t%12-15,22D, %16-19,7D, %D"},
702 {FPU_NEON_EXT_V1, 0xf3800040, 0xff800f50, "vmla%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
703 {FPU_NEON_EXT_V1, 0xf3800140, 0xff800f50, "vmla%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
704 {FPU_NEON_EXT_V1, 0xf3800440, 0xff800f50, "vmls%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
705 {FPU_NEON_EXT_V1, 0xf3800540, 0xff800f50, "vmls%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
706 {FPU_NEON_EXT_V1, 0xf3800840, 0xff800f50, "vmul%c.i%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
707 {FPU_NEON_EXT_V1, 0xf3800940, 0xff800f50, "vmul%c.f%20-21Sa\t%12-15,22Q, %16-19,7Q, %D"},
708 {FPU_NEON_EXT_V1, 0xf3800c40, 0xff800f50, "vqdmulh%c.s%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
709 {FPU_NEON_EXT_V1, 0xf3800d40, 0xff800f50, "vqrdmulh%c.s%20-21S6\t%12-15,22Q, %16-19,7Q, %D"},
710 {FPU_NEON_EXT_V1, 0xf2800240, 0xfe800f50, "vmlal%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
711 {FPU_NEON_EXT_V1, 0xf2800640, 0xfe800f50, "vmlsl%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
712 {FPU_NEON_EXT_V1, 0xf2800a40, 0xfe800f50, "vmull%c.%24?us%20-21S6\t%12-15,22Q, %16-19,7D, %D"},
713
714 /* Element and structure load/store */
715 {FPU_NEON_EXT_V1, 0xf4a00fc0, 0xffb00fc0, "vld4%c.32\t%C"},
716 {FPU_NEON_EXT_V1, 0xf4a00c00, 0xffb00f00, "vld1%c.%6-7S2\t%C"},
717 {FPU_NEON_EXT_V1, 0xf4a00d00, 0xffb00f00, "vld2%c.%6-7S2\t%C"},
718 {FPU_NEON_EXT_V1, 0xf4a00e00, 0xffb00f00, "vld3%c.%6-7S2\t%C"},
719 {FPU_NEON_EXT_V1, 0xf4a00f00, 0xffb00f00, "vld4%c.%6-7S2\t%C"},
720 {FPU_NEON_EXT_V1, 0xf4000200, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
721 {FPU_NEON_EXT_V1, 0xf4000300, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
722 {FPU_NEON_EXT_V1, 0xf4000400, 0xff900f00, "v%21?ls%21?dt3%c.%6-7S2\t%A"},
723 {FPU_NEON_EXT_V1, 0xf4000500, 0xff900f00, "v%21?ls%21?dt3%c.%6-7S2\t%A"},
724 {FPU_NEON_EXT_V1, 0xf4000600, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
725 {FPU_NEON_EXT_V1, 0xf4000700, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
726 {FPU_NEON_EXT_V1, 0xf4000800, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
727 {FPU_NEON_EXT_V1, 0xf4000900, 0xff900f00, "v%21?ls%21?dt2%c.%6-7S2\t%A"},
728 {FPU_NEON_EXT_V1, 0xf4000a00, 0xff900f00, "v%21?ls%21?dt1%c.%6-7S3\t%A"},
729 {FPU_NEON_EXT_V1, 0xf4000000, 0xff900e00, "v%21?ls%21?dt4%c.%6-7S2\t%A"},
730 {FPU_NEON_EXT_V1, 0xf4800000, 0xff900300, "v%21?ls%21?dt1%c.%10-11S2\t%B"},
731 {FPU_NEON_EXT_V1, 0xf4800100, 0xff900300, "v%21?ls%21?dt2%c.%10-11S2\t%B"},
732 {FPU_NEON_EXT_V1, 0xf4800200, 0xff900300, "v%21?ls%21?dt3%c.%10-11S2\t%B"},
733 {FPU_NEON_EXT_V1, 0xf4800300, 0xff900300, "v%21?ls%21?dt4%c.%10-11S2\t%B"},
734
735 {0,0 ,0, 0}
736 };
737
738 /* Opcode tables: ARM, 16-bit Thumb, 32-bit Thumb. All three are partially
739 ordered: they must be searched linearly from the top to obtain a correct
740 match. */
741
742 /* print_insn_arm recognizes the following format control codes:
743
744 %% %
745
746 %a print address for ldr/str instruction
747 %s print address for ldr/str halfword/signextend instruction
748 %b print branch destination
749 %c print condition code (always bits 28-31)
750 %m print register mask for ldm/stm instruction
751 %o print operand2 (immediate or register + shift)
752 %p print 'p' iff bits 12-15 are 15
753 %t print 't' iff bit 21 set and bit 24 clear
754 %B print arm BLX(1) destination
755 %C print the PSR sub type.
756 %U print barrier type.
757 %P print address for pli instruction.
758
759 %<bitfield>r print as an ARM register
760 %<bitfield>d print the bitfield in decimal
761 %<bitfield>W print the bitfield plus one in decimal
762 %<bitfield>x print the bitfield in hex
763 %<bitfield>X print the bitfield as 1 hex digit without leading "0x"
764
765 %<bitfield>'c print specified char iff bitfield is all ones
766 %<bitfield>`c print specified char iff bitfield is all zeroes
767 %<bitfield>?ab... select from array of values in big endian order
768
769 %e print arm SMI operand (bits 0..7,8..19).
770 %E print the LSB and WIDTH fields of a BFI or BFC instruction.
771 %V print the 16-bit immediate field of a MOVT or MOVW instruction. */
772
773 static const struct opcode32 arm_opcodes[] =
774 {
775 /* ARM instructions. */
776 {ARM_EXT_V1, 0xe1a00000, 0xffffffff, "nop\t\t\t(mov r0,r0)"},
777 {ARM_EXT_V4T | ARM_EXT_V5, 0x012FFF10, 0x0ffffff0, "bx%c\t%0-3r"},
778 {ARM_EXT_V2, 0x00000090, 0x0fe000f0, "mul%20's%c\t%16-19r, %0-3r, %8-11r"},
779 {ARM_EXT_V2, 0x00200090, 0x0fe000f0, "mla%20's%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
780 {ARM_EXT_V2S, 0x01000090, 0x0fb00ff0, "swp%22'b%c\t%12-15r, %0-3r, [%16-19r]"},
781 {ARM_EXT_V3M, 0x00800090, 0x0fa000f0, "%22?sumull%20's%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
782 {ARM_EXT_V3M, 0x00a00090, 0x0fa000f0, "%22?sumlal%20's%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
783
784 /* V7 instructions. */
785 {ARM_EXT_V7, 0xf450f000, 0xfd70f000, "pli\t%P"},
786 {ARM_EXT_V7, 0x0320f0f0, 0x0ffffff0, "dbg%c\t#%0-3d"},
787 {ARM_EXT_V7, 0xf57ff050, 0xfffffff0, "dmb\t%U"},
788 {ARM_EXT_V7, 0xf57ff040, 0xfffffff0, "dsb\t%U"},
789 {ARM_EXT_V7, 0xf57ff060, 0xfffffff0, "isb\t%U"},
790
791 /* ARM V6T2 instructions. */
792 {ARM_EXT_V6T2, 0x07c0001f, 0x0fe0007f, "bfc%c\t%12-15r, %E"},
793 {ARM_EXT_V6T2, 0x07c00010, 0x0fe00070, "bfi%c\t%12-15r, %0-3r, %E"},
794 {ARM_EXT_V6T2, 0x00600090, 0x0ff000f0, "mls%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
795 {ARM_EXT_V6T2, 0x006000b0, 0x0f7000f0, "strht%c\t%12-15r, %s"},
796 {ARM_EXT_V6T2, 0x00300090, 0x0f300090, "ldr%6's%5?hbt%c\t%12-15r, %s"},
797 {ARM_EXT_V6T2, 0x03000000, 0x0ff00000, "movw%c\t%12-15r, %V"},
798 {ARM_EXT_V6T2, 0x03400000, 0x0ff00000, "movt%c\t%12-15r, %V"},
799 {ARM_EXT_V6T2, 0x06ff0f30, 0x0fff0ff0, "rbit%c\t%12-15r, %0-3r"},
800 {ARM_EXT_V6T2, 0x07a00050, 0x0fa00070, "%22?usbfx%c\t%12-15r, %0-3r, #%7-11d, #%16-20W"},
801
802 /* ARM V6Z instructions. */
803 {ARM_EXT_V6Z, 0x01600070, 0x0ff000f0, "smc%c\t%e"},
804
805 /* ARM V6K instructions. */
806 {ARM_EXT_V6K, 0xf57ff01f, 0xffffffff, "clrex"},
807 {ARM_EXT_V6K, 0x01d00f9f, 0x0ff00fff, "ldrexb%c\t%12-15r, [%16-19r]"},
808 {ARM_EXT_V6K, 0x01b00f9f, 0x0ff00fff, "ldrexd%c\t%12-15r, [%16-19r]"},
809 {ARM_EXT_V6K, 0x01f00f9f, 0x0ff00fff, "ldrexh%c\t%12-15r, [%16-19r]"},
810 {ARM_EXT_V6K, 0x01c00f90, 0x0ff00ff0, "strexb%c\t%12-15r, %0-3r, [%16-19r]"},
811 {ARM_EXT_V6K, 0x01a00f90, 0x0ff00ff0, "strexd%c\t%12-15r, %0-3r, [%16-19r]"},
812 {ARM_EXT_V6K, 0x01e00f90, 0x0ff00ff0, "strexh%c\t%12-15r, %0-3r, [%16-19r]"},
813
814 /* ARM V6K NOP hints. */
815 {ARM_EXT_V6K, 0x0320f001, 0x0fffffff, "yield%c"},
816 {ARM_EXT_V6K, 0x0320f002, 0x0fffffff, "wfe%c"},
817 {ARM_EXT_V6K, 0x0320f003, 0x0fffffff, "wfi%c"},
818 {ARM_EXT_V6K, 0x0320f004, 0x0fffffff, "sev%c"},
819 {ARM_EXT_V6K, 0x0320f000, 0x0fffff00, "nop%c\t{%0-7d}"},
820
821 /* ARM V6 instructions. */
822 {ARM_EXT_V6, 0xf1080000, 0xfffffe3f, "cpsie\t%8'a%7'i%6'f"},
823 {ARM_EXT_V6, 0xf10a0000, 0xfffffe20, "cpsie\t%8'a%7'i%6'f,#%0-4d"},
824 {ARM_EXT_V6, 0xf10C0000, 0xfffffe3f, "cpsid\t%8'a%7'i%6'f"},
825 {ARM_EXT_V6, 0xf10e0000, 0xfffffe20, "cpsid\t%8'a%7'i%6'f,#%0-4d"},
826 {ARM_EXT_V6, 0xf1000000, 0xfff1fe20, "cps\t#%0-4d"},
827 {ARM_EXT_V6, 0x06800010, 0x0ff00ff0, "pkhbt%c\t%12-15r, %16-19r, %0-3r"},
828 {ARM_EXT_V6, 0x06800010, 0x0ff00070, "pkhbt%c\t%12-15r, %16-19r, %0-3r, lsl #%7-11d"},
829 {ARM_EXT_V6, 0x06800050, 0x0ff00ff0, "pkhtb%c\t%12-15r, %16-19r, %0-3r, asr #32"},
830 {ARM_EXT_V6, 0x06800050, 0x0ff00070, "pkhtb%c\t%12-15r, %16-19r, %0-3r, asr #%7-11d"},
831 {ARM_EXT_V6, 0x01900f9f, 0x0ff00fff, "ldrex%c\tr%12-15d, [%16-19r]"},
832 {ARM_EXT_V6, 0x06200f10, 0x0ff00ff0, "qadd16%c\t%12-15r, %16-19r, %0-3r"},
833 {ARM_EXT_V6, 0x06200f90, 0x0ff00ff0, "qadd8%c\t%12-15r, %16-19r, %0-3r"},
834 {ARM_EXT_V6, 0x06200f30, 0x0ff00ff0, "qaddsubx%c\t%12-15r, %16-19r, %0-3r"},
835 {ARM_EXT_V6, 0x06200f70, 0x0ff00ff0, "qsub16%c\t%12-15r, %16-19r, %0-3r"},
836 {ARM_EXT_V6, 0x06200ff0, 0x0ff00ff0, "qsub8%c\t%12-15r, %16-19r, %0-3r"},
837 {ARM_EXT_V6, 0x06200f50, 0x0ff00ff0, "qsubaddx%c\t%12-15r, %16-19r, %0-3r"},
838 {ARM_EXT_V6, 0x06100f10, 0x0ff00ff0, "sadd16%c\t%12-15r, %16-19r, %0-3r"},
839 {ARM_EXT_V6, 0x06100f90, 0x0ff00ff0, "sadd8%c\t%12-15r, %16-19r, %0-3r"},
840 {ARM_EXT_V6, 0x06100f30, 0x0ff00ff0, "saddaddx%c\t%12-15r, %16-19r, %0-3r"},
841 {ARM_EXT_V6, 0x06300f10, 0x0ff00ff0, "shadd16%c\t%12-15r, %16-19r, %0-3r"},
842 {ARM_EXT_V6, 0x06300f90, 0x0ff00ff0, "shadd8%c\t%12-15r, %16-19r, %0-3r"},
843 {ARM_EXT_V6, 0x06300f30, 0x0ff00ff0, "shaddsubx%c\t%12-15r, %16-19r, %0-3r"},
844 {ARM_EXT_V6, 0x06300f70, 0x0ff00ff0, "shsub16%c\t%12-15r, %16-19r, %0-3r"},
845 {ARM_EXT_V6, 0x06300ff0, 0x0ff00ff0, "shsub8%c\t%12-15r, %16-19r, %0-3r"},
846 {ARM_EXT_V6, 0x06300f50, 0x0ff00ff0, "shsubaddx%c\t%12-15r, %16-19r, %0-3r"},
847 {ARM_EXT_V6, 0x06100f70, 0x0ff00ff0, "ssub16%c\t%12-15r, %16-19r, %0-3r"},
848 {ARM_EXT_V6, 0x06100ff0, 0x0ff00ff0, "ssub8%c\t%12-15r, %16-19r, %0-3r"},
849 {ARM_EXT_V6, 0x06100f50, 0x0ff00ff0, "ssubaddx%c\t%12-15r, %16-19r, %0-3r"},
850 {ARM_EXT_V6, 0x06500f10, 0x0ff00ff0, "uadd16%c\t%12-15r, %16-19r, %0-3r"},
851 {ARM_EXT_V6, 0x06500f90, 0x0ff00ff0, "uadd8%c\t%12-15r, %16-19r, %0-3r"},
852 {ARM_EXT_V6, 0x06500f30, 0x0ff00ff0, "uaddsubx%c\t%12-15r, %16-19r, %0-3r"},
853 {ARM_EXT_V6, 0x06700f10, 0x0ff00ff0, "uhadd16%c\t%12-15r, %16-19r, %0-3r"},
854 {ARM_EXT_V6, 0x06700f90, 0x0ff00ff0, "uhadd8%c\t%12-15r, %16-19r, %0-3r"},
855 {ARM_EXT_V6, 0x06700f30, 0x0ff00ff0, "uhaddsubx%c\t%12-15r, %16-19r, %0-3r"},
856 {ARM_EXT_V6, 0x06700f70, 0x0ff00ff0, "uhsub16%c\t%12-15r, %16-19r, %0-3r"},
857 {ARM_EXT_V6, 0x06700ff0, 0x0ff00ff0, "uhsub8%c\t%12-15r, %16-19r, %0-3r"},
858 {ARM_EXT_V6, 0x06700f50, 0x0ff00ff0, "uhsubaddx%c\t%12-15r, %16-19r, %0-3r"},
859 {ARM_EXT_V6, 0x06600f10, 0x0ff00ff0, "uqadd16%c\t%12-15r, %16-19r, %0-3r"},
860 {ARM_EXT_V6, 0x06600f90, 0x0ff00ff0, "uqadd8%c\t%12-15r, %16-19r, %0-3r"},
861 {ARM_EXT_V6, 0x06600f30, 0x0ff00ff0, "uqaddsubx%c\t%12-15r, %16-19r, %0-3r"},
862 {ARM_EXT_V6, 0x06600f70, 0x0ff00ff0, "uqsub16%c\t%12-15r, %16-19r, %0-3r"},
863 {ARM_EXT_V6, 0x06600ff0, 0x0ff00ff0, "uqsub8%c\t%12-15r, %16-19r, %0-3r"},
864 {ARM_EXT_V6, 0x06600f50, 0x0ff00ff0, "uqsubaddx%c\t%12-15r, %16-19r, %0-3r"},
865 {ARM_EXT_V6, 0x06500f70, 0x0ff00ff0, "usub16%c\t%12-15r, %16-19r, %0-3r"},
866 {ARM_EXT_V6, 0x06500ff0, 0x0ff00ff0, "usub8%c\t%12-15r, %16-19r, %0-3r"},
867 {ARM_EXT_V6, 0x06500f50, 0x0ff00ff0, "usubaddx%c\t%12-15r, %16-19r, %0-3r"},
868 {ARM_EXT_V6, 0x06bf0f30, 0x0fff0ff0, "rev%c\t\%12-15r, %0-3r"},
869 {ARM_EXT_V6, 0x06bf0fb0, 0x0fff0ff0, "rev16%c\t\%12-15r, %0-3r"},
870 {ARM_EXT_V6, 0x06ff0fb0, 0x0fff0ff0, "revsh%c\t\%12-15r, %0-3r"},
871 {ARM_EXT_V6, 0xf8100a00, 0xfe50ffff, "rfe%23?id%24?ba\t\%16-19r%21'!"},
872 {ARM_EXT_V6, 0x06bf0070, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r"},
873 {ARM_EXT_V6, 0x06bf0470, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #8"},
874 {ARM_EXT_V6, 0x06bf0870, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #16"},
875 {ARM_EXT_V6, 0x06bf0c70, 0x0fff0ff0, "sxth%c\t%12-15r, %0-3r, ror #24"},
876 {ARM_EXT_V6, 0x068f0070, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r"},
877 {ARM_EXT_V6, 0x068f0470, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #8"},
878 {ARM_EXT_V6, 0x068f0870, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #16"},
879 {ARM_EXT_V6, 0x068f0c70, 0x0fff0ff0, "sxtb16%c\t%12-15r, %0-3r, ror #24"},
880 {ARM_EXT_V6, 0x06af0070, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r"},
881 {ARM_EXT_V6, 0x06af0470, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #8"},
882 {ARM_EXT_V6, 0x06af0870, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #16"},
883 {ARM_EXT_V6, 0x06af0c70, 0x0fff0ff0, "sxtb%c\t%12-15r, %0-3r, ror #24"},
884 {ARM_EXT_V6, 0x06ff0070, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r"},
885 {ARM_EXT_V6, 0x06ff0470, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #8"},
886 {ARM_EXT_V6, 0x06ff0870, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #16"},
887 {ARM_EXT_V6, 0x06ff0c70, 0x0fff0ff0, "uxth%c\t%12-15r, %0-3r, ror #24"},
888 {ARM_EXT_V6, 0x06cf0070, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r"},
889 {ARM_EXT_V6, 0x06cf0470, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #8"},
890 {ARM_EXT_V6, 0x06cf0870, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #16"},
891 {ARM_EXT_V6, 0x06cf0c70, 0x0fff0ff0, "uxtb16%c\t%12-15r, %0-3r, ror #24"},
892 {ARM_EXT_V6, 0x06ef0070, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r"},
893 {ARM_EXT_V6, 0x06ef0470, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #8"},
894 {ARM_EXT_V6, 0x06ef0870, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #16"},
895 {ARM_EXT_V6, 0x06ef0c70, 0x0fff0ff0, "uxtb%c\t%12-15r, %0-3r, ror #24"},
896 {ARM_EXT_V6, 0x06b00070, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r"},
897 {ARM_EXT_V6, 0x06b00470, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #8"},
898 {ARM_EXT_V6, 0x06b00870, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #16"},
899 {ARM_EXT_V6, 0x06b00c70, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ror #24"},
900 {ARM_EXT_V6, 0x06800070, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r"},
901 {ARM_EXT_V6, 0x06800470, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #8"},
902 {ARM_EXT_V6, 0x06800870, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #16"},
903 {ARM_EXT_V6, 0x06800c70, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ror #24"},
904 {ARM_EXT_V6, 0x06a00070, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r"},
905 {ARM_EXT_V6, 0x06a00470, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #8"},
906 {ARM_EXT_V6, 0x06a00870, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #16"},
907 {ARM_EXT_V6, 0x06a00c70, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ror #24"},
908 {ARM_EXT_V6, 0x06f00070, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r"},
909 {ARM_EXT_V6, 0x06f00470, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #8"},
910 {ARM_EXT_V6, 0x06f00870, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #16"},
911 {ARM_EXT_V6, 0x06f00c70, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ror #24"},
912 {ARM_EXT_V6, 0x06c00070, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r"},
913 {ARM_EXT_V6, 0x06c00470, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ror #8"},
914 {ARM_EXT_V6, 0x06c00870, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ror #16"},
915 {ARM_EXT_V6, 0x06c00c70, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
916 {ARM_EXT_V6, 0x06e00070, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r"},
917 {ARM_EXT_V6, 0x06e00470, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #8"},
918 {ARM_EXT_V6, 0x06e00870, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #16"},
919 {ARM_EXT_V6, 0x06e00c70, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ror #24"},
920 {ARM_EXT_V6, 0x06800fb0, 0x0ff00ff0, "sel%c\t%12-15r, %16-19r, %0-3r"},
921 {ARM_EXT_V6, 0xf1010000, 0xfffffc00, "setend\t%9?ble"},
922 {ARM_EXT_V6, 0x0700f010, 0x0ff0f0d0, "smuad%5'x%c\t%16-19r, %0-3r, %8-11r"},
923 {ARM_EXT_V6, 0x0700f050, 0x0ff0f0d0, "smusd%5'x%c\t%16-19r, %0-3r, %8-11r"},
924 {ARM_EXT_V6, 0x07000010, 0x0ff000d0, "smlad%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
925 {ARM_EXT_V6, 0x07400010, 0x0ff000d0, "smlald%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
926 {ARM_EXT_V6, 0x07000050, 0x0ff000d0, "smlsd%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
927 {ARM_EXT_V6, 0x07400050, 0x0ff000d0, "smlsld%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
928 {ARM_EXT_V6, 0x0750f010, 0x0ff0f0d0, "smmul%5'r%c\t%16-19r, %0-3r, %8-11r"},
929 {ARM_EXT_V6, 0x07500010, 0x0ff000d0, "smmla%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
930 {ARM_EXT_V6, 0x075000d0, 0x0ff000d0, "smmls%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
931 {ARM_EXT_V6, 0xf84d0500, 0xfe5fffe0, "srs%23?id%24?ba\t%16-19r%21'!, #%0-4d"},
932 {ARM_EXT_V6, 0x06a00010, 0x0fe00ff0, "ssat%c\t%12-15r, #%16-20W, %0-3r"},
933 {ARM_EXT_V6, 0x06a00010, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, lsl #%7-11d"},
934 {ARM_EXT_V6, 0x06a00050, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, asr #%7-11d"},
935 {ARM_EXT_V6, 0x06a00f30, 0x0ff00ff0, "ssat16%c\t%12-15r, #%16-19W, %0-3r"},
936 {ARM_EXT_V6, 0x01800f90, 0x0ff00ff0, "strex%c\t%12-15r, %0-3r, [%16-19r]"},
937 {ARM_EXT_V6, 0x00400090, 0x0ff000f0, "umaal%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
938 {ARM_EXT_V6, 0x0780f010, 0x0ff0f0f0, "usad8%c\t%16-19r, %0-3r, %8-11r"},
939 {ARM_EXT_V6, 0x07800010, 0x0ff000f0, "usada8%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
940 {ARM_EXT_V6, 0x06e00010, 0x0fe00ff0, "usat%c\t%12-15r, #%16-20d, %0-3r"},
941 {ARM_EXT_V6, 0x06e00010, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, lsl #%7-11d"},
942 {ARM_EXT_V6, 0x06e00050, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, asr #%7-11d"},
943 {ARM_EXT_V6, 0x06e00f30, 0x0ff00ff0, "usat16%c\t%12-15r, #%16-19d, %0-3r"},
944
945 /* V5J instruction. */
946 {ARM_EXT_V5J, 0x012fff20, 0x0ffffff0, "bxj%c\t%0-3r"},
947
948 /* V5 Instructions. */
949 {ARM_EXT_V5, 0xe1200070, 0xfff000f0, "bkpt\t0x%16-19X%12-15X%8-11X%0-3X"},
950 {ARM_EXT_V5, 0xfa000000, 0xfe000000, "blx\t%B"},
951 {ARM_EXT_V5, 0x012fff30, 0x0ffffff0, "blx%c\t%0-3r"},
952 {ARM_EXT_V5, 0x016f0f10, 0x0fff0ff0, "clz%c\t%12-15r, %0-3r"},
953
954 /* V5E "El Segundo" Instructions. */
955 {ARM_EXT_V5E, 0x000000d0, 0x0e1000f0, "ldrd%c\t%12-15r, %s"},
956 {ARM_EXT_V5E, 0x000000f0, 0x0e1000f0, "strd%c\t%12-15r, %s"},
957 {ARM_EXT_V5E, 0xf450f000, 0xfc70f000, "pld\t%a"},
958 {ARM_EXT_V5ExP, 0x01000080, 0x0ff000f0, "smlabb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
959 {ARM_EXT_V5ExP, 0x010000a0, 0x0ff000f0, "smlatb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
960 {ARM_EXT_V5ExP, 0x010000c0, 0x0ff000f0, "smlabt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
961 {ARM_EXT_V5ExP, 0x010000e0, 0x0ff000f0, "smlatt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
962
963 {ARM_EXT_V5ExP, 0x01200080, 0x0ff000f0, "smlawb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
964 {ARM_EXT_V5ExP, 0x012000c0, 0x0ff000f0, "smlawt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
965
966 {ARM_EXT_V5ExP, 0x01400080, 0x0ff000f0, "smlalbb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
967 {ARM_EXT_V5ExP, 0x014000a0, 0x0ff000f0, "smlaltb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
968 {ARM_EXT_V5ExP, 0x014000c0, 0x0ff000f0, "smlalbt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
969 {ARM_EXT_V5ExP, 0x014000e0, 0x0ff000f0, "smlaltt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
970
971 {ARM_EXT_V5ExP, 0x01600080, 0x0ff0f0f0, "smulbb%c\t%16-19r, %0-3r, %8-11r"},
972 {ARM_EXT_V5ExP, 0x016000a0, 0x0ff0f0f0, "smultb%c\t%16-19r, %0-3r, %8-11r"},
973 {ARM_EXT_V5ExP, 0x016000c0, 0x0ff0f0f0, "smulbt%c\t%16-19r, %0-3r, %8-11r"},
974 {ARM_EXT_V5ExP, 0x016000e0, 0x0ff0f0f0, "smultt%c\t%16-19r, %0-3r, %8-11r"},
975
976 {ARM_EXT_V5ExP, 0x012000a0, 0x0ff0f0f0, "smulwb%c\t%16-19r, %0-3r, %8-11r"},
977 {ARM_EXT_V5ExP, 0x012000e0, 0x0ff0f0f0, "smulwt%c\t%16-19r, %0-3r, %8-11r"},
978
979 {ARM_EXT_V5ExP, 0x01000050, 0x0ff00ff0, "qadd%c\t%12-15r, %0-3r, %16-19r"},
980 {ARM_EXT_V5ExP, 0x01400050, 0x0ff00ff0, "qdadd%c\t%12-15r, %0-3r, %16-19r"},
981 {ARM_EXT_V5ExP, 0x01200050, 0x0ff00ff0, "qsub%c\t%12-15r, %0-3r, %16-19r"},
982 {ARM_EXT_V5ExP, 0x01600050, 0x0ff00ff0, "qdsub%c\t%12-15r, %0-3r, %16-19r"},
983
984 /* ARM Instructions. */
985 {ARM_EXT_V1, 0x00000090, 0x0e100090, "str%6's%5?hb%c\t%12-15r, %s"},
986 {ARM_EXT_V1, 0x00100090, 0x0e100090, "ldr%6's%5?hb%c\t%12-15r, %s"},
987 {ARM_EXT_V1, 0x00000000, 0x0de00000, "and%20's%c\t%12-15r, %16-19r, %o"},
988 {ARM_EXT_V1, 0x00200000, 0x0de00000, "eor%20's%c\t%12-15r, %16-19r, %o"},
989 {ARM_EXT_V1, 0x00400000, 0x0de00000, "sub%20's%c\t%12-15r, %16-19r, %o"},
990 {ARM_EXT_V1, 0x00600000, 0x0de00000, "rsb%20's%c\t%12-15r, %16-19r, %o"},
991 {ARM_EXT_V1, 0x00800000, 0x0de00000, "add%20's%c\t%12-15r, %16-19r, %o"},
992 {ARM_EXT_V1, 0x00a00000, 0x0de00000, "adc%20's%c\t%12-15r, %16-19r, %o"},
993 {ARM_EXT_V1, 0x00c00000, 0x0de00000, "sbc%20's%c\t%12-15r, %16-19r, %o"},
994 {ARM_EXT_V1, 0x00e00000, 0x0de00000, "rsc%20's%c\t%12-15r, %16-19r, %o"},
995 {ARM_EXT_V3, 0x0120f000, 0x0db0f000, "msr%c\t%22?SCPSR%C, %o"},
996 {ARM_EXT_V3, 0x010f0000, 0x0fbf0fff, "mrs%c\t%12-15r, %22?SCPSR"},
997 {ARM_EXT_V1, 0x01000000, 0x0de00000, "tst%p%c\t%16-19r, %o"},
998 {ARM_EXT_V1, 0x01200000, 0x0de00000, "teq%p%c\t%16-19r, %o"},
999 {ARM_EXT_V1, 0x01400000, 0x0de00000, "cmp%p%c\t%16-19r, %o"},
1000 {ARM_EXT_V1, 0x01600000, 0x0de00000, "cmn%p%c\t%16-19r, %o"},
1001 {ARM_EXT_V1, 0x01800000, 0x0de00000, "orr%20's%c\t%12-15r, %16-19r, %o"},
1002 {ARM_EXT_V1, 0x03a00000, 0x0fef0000, "mov%20's%c\t%12-15r, %o"},
1003 {ARM_EXT_V1, 0x01a00000, 0x0def0ff0, "mov%20's%c\t%12-15r, %0-3r"},
1004 {ARM_EXT_V1, 0x01a00000, 0x0def0060, "lsl%20's%c\t%12-15r, %q"},
1005 {ARM_EXT_V1, 0x01a00020, 0x0def0060, "lsr%20's%c\t%12-15r, %q"},
1006 {ARM_EXT_V1, 0x01a00040, 0x0def0060, "asr%20's%c\t%12-15r, %q"},
1007 {ARM_EXT_V1, 0x01a00060, 0x0def0ff0, "rrx%20's%c\t%12-15r, %0-3r"},
1008 {ARM_EXT_V1, 0x01a00060, 0x0def0060, "ror%20's%c\t%12-15r, %q"},
1009 {ARM_EXT_V1, 0x01c00000, 0x0de00000, "bic%20's%c\t%12-15r, %16-19r, %o"},
1010 {ARM_EXT_V1, 0x01e00000, 0x0de00000, "mvn%20's%c\t%12-15r, %o"},
1011 {ARM_EXT_V1, 0x052d0004, 0x0fff0fff, "push%c\t{%12-15r}\t\t; (str%c %12-15r, %a)"},
1012 {ARM_EXT_V1, 0x04000000, 0x0e100000, "str%22'b%t%c\t%12-15r, %a"},
1013 {ARM_EXT_V1, 0x06000000, 0x0e100ff0, "str%22'b%t%c\t%12-15r, %a"},
1014 {ARM_EXT_V1, 0x04000000, 0x0c100010, "str%22'b%t%c\t%12-15r, %a"},
1015 {ARM_EXT_V1, 0x06000010, 0x0e000010, "undefined"},
1016 {ARM_EXT_V1, 0x049d0004, 0x0fff0fff, "pop%c\t{%12-15r}\t\t; (ldr%c %12-15r, %a)"},
1017 {ARM_EXT_V1, 0x04100000, 0x0c100000, "ldr%22'b%t%c\t%12-15r, %a"},
1018 {ARM_EXT_V1, 0x092d0000, 0x0fff0000, "push%c\t%m"},
1019 {ARM_EXT_V1, 0x08800000, 0x0ff00000, "stm%c\t%16-19r%21'!, %m%22'^"},
1020 {ARM_EXT_V1, 0x08000000, 0x0e100000, "stm%23?id%24?ba%c\t%16-19r%21'!, %m%22'^"},
1021 {ARM_EXT_V1, 0x08bd0000, 0x0fff0000, "pop%c\t%m"},
1022 {ARM_EXT_V1, 0x08900000, 0x0f900000, "ldm%c\t%16-19r%21'!, %m%22'^"},
1023 {ARM_EXT_V1, 0x08100000, 0x0e100000, "ldm%23?id%24?ba%c\t%16-19r%21'!, %m%22'^"},
1024 {ARM_EXT_V1, 0x0a000000, 0x0e000000, "b%24'l%c\t%b"},
1025 {ARM_EXT_V1, 0x0f000000, 0x0f000000, "svc%c\t%0-23x"},
1026
1027 /* The rest. */
1028 {ARM_EXT_V1, 0x00000000, 0x00000000, "undefined instruction %0-31x"},
1029 {0, 0x00000000, 0x00000000, 0}
1030 };
1031
1032 /* print_insn_thumb16 recognizes the following format control codes:
1033
1034 %S print Thumb register (bits 3..5 as high number if bit 6 set)
1035 %D print Thumb register (bits 0..2 as high number if bit 7 set)
1036 %<bitfield>I print bitfield as a signed decimal
1037 (top bit of range being the sign bit)
1038 %N print Thumb register mask (with LR)
1039 %O print Thumb register mask (with PC)
1040 %M print Thumb register mask
1041 %b print CZB's 6-bit unsigned branch destination
1042 %s print Thumb right-shift immediate (6..10; 0 == 32).
1043 %c print the condition code
1044 %C print the condition code, or "s" if not conditional
1045 %x print warning if conditional an not at end of IT block"
1046 %X print "\t; unpredictable <IT:code>" if conditional
1047 %I print IT instruction suffix and operands
1048 %<bitfield>r print bitfield as an ARM register
1049 %<bitfield>d print bitfield as a decimal
1050 %<bitfield>H print (bitfield * 2) as a decimal
1051 %<bitfield>W print (bitfield * 4) as a decimal
1052 %<bitfield>a print (bitfield * 4) as a pc-rel offset + decoded symbol
1053 %<bitfield>B print Thumb branch destination (signed displacement)
1054 %<bitfield>c print bitfield as a condition code
1055 %<bitnum>'c print specified char iff bit is one
1056 %<bitnum>?ab print a if bit is one else print b. */
1057
1058 static const struct opcode16 thumb_opcodes[] =
1059 {
1060 /* Thumb instructions. */
1061
1062 /* ARM V6K no-argument instructions. */
1063 {ARM_EXT_V6K, 0xbf00, 0xffff, "nop%c"},
1064 {ARM_EXT_V6K, 0xbf10, 0xffff, "yield%c"},
1065 {ARM_EXT_V6K, 0xbf20, 0xffff, "wfe%c"},
1066 {ARM_EXT_V6K, 0xbf30, 0xffff, "wfi%c"},
1067 {ARM_EXT_V6K, 0xbf40, 0xffff, "sev%c"},
1068 {ARM_EXT_V6K, 0xbf00, 0xff0f, "nop%c\t{%4-7d}"},
1069
1070 /* ARM V6T2 instructions. */
1071 {ARM_EXT_V6T2, 0xb900, 0xfd00, "cbnz\t%0-2r, %b%X"},
1072 {ARM_EXT_V6T2, 0xb100, 0xfd00, "cbz\t%0-2r, %b%X"},
1073 {ARM_EXT_V6T2, 0xbf00, 0xff00, "it%I%X"},
1074
1075 /* ARM V6. */
1076 {ARM_EXT_V6, 0xb660, 0xfff8, "cpsie\t%2'a%1'i%0'f%X"},
1077 {ARM_EXT_V6, 0xb670, 0xfff8, "cpsid\t%2'a%1'i%0'f%X"},
1078 {ARM_EXT_V6, 0x4600, 0xffc0, "mov%c\t%0-2r, %3-5r"},
1079 {ARM_EXT_V6, 0xba00, 0xffc0, "rev%c\t%0-2r, %3-5r"},
1080 {ARM_EXT_V6, 0xba40, 0xffc0, "rev16%c\t%0-2r, %3-5r"},
1081 {ARM_EXT_V6, 0xbac0, 0xffc0, "revsh%c\t%0-2r, %3-5r"},
1082 {ARM_EXT_V6, 0xb650, 0xfff7, "setend\t%3?ble%X"},
1083 {ARM_EXT_V6, 0xb200, 0xffc0, "sxth%c\t%0-2r, %3-5r"},
1084 {ARM_EXT_V6, 0xb240, 0xffc0, "sxtb%c\t%0-2r, %3-5r"},
1085 {ARM_EXT_V6, 0xb280, 0xffc0, "uxth%c\t%0-2r, %3-5r"},
1086 {ARM_EXT_V6, 0xb2c0, 0xffc0, "uxtb%c\t%0-2r, %3-5r"},
1087
1088 /* ARM V5 ISA extends Thumb. */
1089 {ARM_EXT_V5T, 0xbe00, 0xff00, "bkpt\t%0-7x"}, /* Is always unconditional. */
1090 /* This is BLX(2). BLX(1) is a 32-bit instruction. */
1091 {ARM_EXT_V5T, 0x4780, 0xff87, "blx%c\t%3-6r%x"}, /* note: 4 bit register number. */
1092 /* ARM V4T ISA (Thumb v1). */
1093 {ARM_EXT_V4T, 0x46C0, 0xFFFF, "nop%c\t\t\t(mov r8, r8)"},
1094 /* Format 4. */
1095 {ARM_EXT_V4T, 0x4000, 0xFFC0, "and%C\t%0-2r, %3-5r"},
1096 {ARM_EXT_V4T, 0x4040, 0xFFC0, "eor%C\t%0-2r, %3-5r"},
1097 {ARM_EXT_V4T, 0x4080, 0xFFC0, "lsl%C\t%0-2r, %3-5r"},
1098 {ARM_EXT_V4T, 0x40C0, 0xFFC0, "lsr%C\t%0-2r, %3-5r"},
1099 {ARM_EXT_V4T, 0x4100, 0xFFC0, "asr%C\t%0-2r, %3-5r"},
1100 {ARM_EXT_V4T, 0x4140, 0xFFC0, "adc%C\t%0-2r, %3-5r"},
1101 {ARM_EXT_V4T, 0x4180, 0xFFC0, "sbc%C\t%0-2r, %3-5r"},
1102 {ARM_EXT_V4T, 0x41C0, 0xFFC0, "ror%C\t%0-2r, %3-5r"},
1103 {ARM_EXT_V4T, 0x4200, 0xFFC0, "tst%c\t%0-2r, %3-5r"},
1104 {ARM_EXT_V4T, 0x4240, 0xFFC0, "neg%C\t%0-2r, %3-5r"},
1105 {ARM_EXT_V4T, 0x4280, 0xFFC0, "cmp%c\t%0-2r, %3-5r"},
1106 {ARM_EXT_V4T, 0x42C0, 0xFFC0, "cmn%c\t%0-2r, %3-5r"},
1107 {ARM_EXT_V4T, 0x4300, 0xFFC0, "orr%C\t%0-2r, %3-5r"},
1108 {ARM_EXT_V4T, 0x4340, 0xFFC0, "mul%C\t%0-2r, %3-5r"},
1109 {ARM_EXT_V4T, 0x4380, 0xFFC0, "bic%C\t%0-2r, %3-5r"},
1110 {ARM_EXT_V4T, 0x43C0, 0xFFC0, "mvn%C\t%0-2r, %3-5r"},
1111 /* format 13 */
1112 {ARM_EXT_V4T, 0xB000, 0xFF80, "add%c\tsp, #%0-6W"},
1113 {ARM_EXT_V4T, 0xB080, 0xFF80, "sub%c\tsp, #%0-6W"},
1114 /* format 5 */
1115 {ARM_EXT_V4T, 0x4700, 0xFF80, "bx%c\t%S%x"},
1116 {ARM_EXT_V4T, 0x4400, 0xFF00, "add%c\t%D, %S"},
1117 {ARM_EXT_V4T, 0x4500, 0xFF00, "cmp%c\t%D, %S"},
1118 {ARM_EXT_V4T, 0x4600, 0xFF00, "mov%c\t%D, %S"},
1119 /* format 14 */
1120 {ARM_EXT_V4T, 0xB400, 0xFE00, "push%c\t%N"},
1121 {ARM_EXT_V4T, 0xBC00, 0xFE00, "pop%c\t%O"},
1122 /* format 2 */
1123 {ARM_EXT_V4T, 0x1800, 0xFE00, "add%C\t%0-2r, %3-5r, %6-8r"},
1124 {ARM_EXT_V4T, 0x1A00, 0xFE00, "sub%C\t%0-2r, %3-5r, %6-8r"},
1125 {ARM_EXT_V4T, 0x1C00, 0xFE00, "add%C\t%0-2r, %3-5r, #%6-8d"},
1126 {ARM_EXT_V4T, 0x1E00, 0xFE00, "sub%C\t%0-2r, %3-5r, #%6-8d"},
1127 /* format 8 */
1128 {ARM_EXT_V4T, 0x5200, 0xFE00, "strh%c\t%0-2r, [%3-5r, %6-8r]"},
1129 {ARM_EXT_V4T, 0x5A00, 0xFE00, "ldrh%c\t%0-2r, [%3-5r, %6-8r]"},
1130 {ARM_EXT_V4T, 0x5600, 0xF600, "ldrs%11?hb%c\t%0-2r, [%3-5r, %6-8r]"},
1131 /* format 7 */
1132 {ARM_EXT_V4T, 0x5000, 0xFA00, "str%10'b%c\t%0-2r, [%3-5r, %6-8r]"},
1133 {ARM_EXT_V4T, 0x5800, 0xFA00, "ldr%10'b%c\t%0-2r, [%3-5r, %6-8r]"},
1134 /* format 1 */
1135 {ARM_EXT_V4T, 0x0000, 0xF800, "lsl%C\t%0-2r, %3-5r, #%6-10d"},
1136 {ARM_EXT_V4T, 0x0800, 0xF800, "lsr%C\t%0-2r, %3-5r, %s"},
1137 {ARM_EXT_V4T, 0x1000, 0xF800, "asr%C\t%0-2r, %3-5r, %s"},
1138 /* format 3 */
1139 {ARM_EXT_V4T, 0x2000, 0xF800, "mov%C\t%8-10r, #%0-7d"},
1140 {ARM_EXT_V4T, 0x2800, 0xF800, "cmp%c\t%8-10r, #%0-7d"},
1141 {ARM_EXT_V4T, 0x3000, 0xF800, "add%C\t%8-10r, #%0-7d"},
1142 {ARM_EXT_V4T, 0x3800, 0xF800, "sub%C\t%8-10r, #%0-7d"},
1143 /* format 6 */
1144 {ARM_EXT_V4T, 0x4800, 0xF800, "ldr%c\t%8-10r, [pc, #%0-7W]\t(%0-7a)"}, /* TODO: Disassemble PC relative "LDR rD,=<symbolic>" */
1145 /* format 9 */
1146 {ARM_EXT_V4T, 0x6000, 0xF800, "str%c\t%0-2r, [%3-5r, #%6-10W]"},
1147 {ARM_EXT_V4T, 0x6800, 0xF800, "ldr%c\t%0-2r, [%3-5r, #%6-10W]"},
1148 {ARM_EXT_V4T, 0x7000, 0xF800, "strb%c\t%0-2r, [%3-5r, #%6-10d]"},
1149 {ARM_EXT_V4T, 0x7800, 0xF800, "ldrb%c\t%0-2r, [%3-5r, #%6-10d]"},
1150 /* format 10 */
1151 {ARM_EXT_V4T, 0x8000, 0xF800, "strh%c\t%0-2r, [%3-5r, #%6-10H]"},
1152 {ARM_EXT_V4T, 0x8800, 0xF800, "ldrh%c\t%0-2r, [%3-5r, #%6-10H]"},
1153 /* format 11 */
1154 {ARM_EXT_V4T, 0x9000, 0xF800, "str%c\t%8-10r, [sp, #%0-7W]"},
1155 {ARM_EXT_V4T, 0x9800, 0xF800, "ldr%c\t%8-10r, [sp, #%0-7W]"},
1156 /* format 12 */
1157 {ARM_EXT_V4T, 0xA000, 0xF800, "add%c\t%8-10r, pc, #%0-7W\t(adr %8-10r, %0-7a)"},
1158 {ARM_EXT_V4T, 0xA800, 0xF800, "add%c\t%8-10r, sp, #%0-7W"},
1159 /* format 15 */
1160 {ARM_EXT_V4T, 0xC000, 0xF800, "stmia%c\t%8-10r!, %M"},
1161 {ARM_EXT_V4T, 0xC800, 0xF800, "ldmia%c\t%8-10r!, %M"},
1162 /* format 17 */
1163 {ARM_EXT_V4T, 0xDF00, 0xFF00, "svc%c\t%0-7d"},
1164 /* format 16 */
1165 {ARM_EXT_V4T, 0xDE00, 0xFE00, "undefined"},
1166 {ARM_EXT_V4T, 0xD000, 0xF000, "b%8-11c.n\t%0-7B%X"},
1167 /* format 18 */
1168 {ARM_EXT_V4T, 0xE000, 0xF800, "b%c.n\t%0-10B%x"},
1169
1170 /* The E800 .. FFFF range is unconditionally redirected to the
1171 32-bit table, because even in pre-V6T2 ISAs, BL and BLX(1) pairs
1172 are processed via that table. Thus, we can never encounter a
1173 bare "second half of BL/BLX(1)" instruction here. */
1174 {ARM_EXT_V1, 0x0000, 0x0000, "undefined"},
1175 {0, 0, 0, 0}
1176 };
1177
1178 /* Thumb32 opcodes use the same table structure as the ARM opcodes.
1179 We adopt the convention that hw1 is the high 16 bits of .value and
1180 .mask, hw2 the low 16 bits.
1181
1182 print_insn_thumb32 recognizes the following format control codes:
1183
1184 %% %
1185
1186 %I print a 12-bit immediate from hw1[10],hw2[14:12,7:0]
1187 %M print a modified 12-bit immediate (same location)
1188 %J print a 16-bit immediate from hw1[3:0,10],hw2[14:12,7:0]
1189 %K print a 16-bit immediate from hw2[3:0],hw1[3:0],hw2[11:4]
1190 %S print a possibly-shifted Rm
1191
1192 %a print the address of a plain load/store
1193 %w print the width and signedness of a core load/store
1194 %m print register mask for ldm/stm
1195
1196 %E print the lsb and width fields of a bfc/bfi instruction
1197 %F print the lsb and width fields of a sbfx/ubfx instruction
1198 %b print a conditional branch offset
1199 %B print an unconditional branch offset
1200 %s print the shift field of an SSAT instruction
1201 %R print the rotation field of an SXT instruction
1202 %U print barrier type.
1203 %P print address for pli instruction.
1204 %c print the condition code
1205 %x print warning if conditional an not at end of IT block"
1206 %X print "\t; unpredictable <IT:code>" if conditional
1207
1208 %<bitfield>d print bitfield in decimal
1209 %<bitfield>W print bitfield*4 in decimal
1210 %<bitfield>r print bitfield as an ARM register
1211 %<bitfield>c print bitfield as a condition code
1212
1213 %<bitfield>'c print specified char iff bitfield is all ones
1214 %<bitfield>`c print specified char iff bitfield is all zeroes
1215 %<bitfield>?ab... select from array of values in big endian order
1216
1217 With one exception at the bottom (done because BL and BLX(1) need
1218 to come dead last), this table was machine-sorted first in
1219 decreasing order of number of bits set in the mask, then in
1220 increasing numeric order of mask, then in increasing numeric order
1221 of opcode. This order is not the clearest for a human reader, but
1222 is guaranteed never to catch a special-case bit pattern with a more
1223 general mask, which is important, because this instruction encoding
1224 makes heavy use of special-case bit patterns. */
1225 static const struct opcode32 thumb32_opcodes[] =
1226 {
1227 /* V7 instructions. */
1228 {ARM_EXT_V7, 0xf910f000, 0xff70f000, "pli%c\t%a"},
1229 {ARM_EXT_V7, 0xf3af80f0, 0xfffffff0, "dbg%c\t#%0-3d"},
1230 {ARM_EXT_V7, 0xf3bf8f50, 0xfffffff0, "dmb%c\t%U"},
1231 {ARM_EXT_V7, 0xf3bf8f40, 0xfffffff0, "dsb%c\t%U"},
1232 {ARM_EXT_V7, 0xf3bf8f60, 0xfffffff0, "isb%c\t%U"},
1233 {ARM_EXT_DIV, 0xfb90f0f0, 0xfff0f0f0, "sdiv%c\t%8-11r, %16-19r, %0-3r"},
1234 {ARM_EXT_DIV, 0xfbb0f0f0, 0xfff0f0f0, "udiv%c\t%8-11r, %16-19r, %0-3r"},
1235
1236 /* Instructions defined in the basic V6T2 set. */
1237 {ARM_EXT_V6T2, 0xf3af8000, 0xffffffff, "nop%c.w"},
1238 {ARM_EXT_V6T2, 0xf3af8001, 0xffffffff, "yield%c.w"},
1239 {ARM_EXT_V6T2, 0xf3af8002, 0xffffffff, "wfe%c.w"},
1240 {ARM_EXT_V6T2, 0xf3af8003, 0xffffffff, "wfi%c.w"},
1241 {ARM_EXT_V6T2, 0xf3af9004, 0xffffffff, "sev%c.w"},
1242 {ARM_EXT_V6T2, 0xf3af8000, 0xffffff00, "nop%c.w\t{%0-7d}"},
1243
1244 {ARM_EXT_V6T2, 0xf3bf8f2f, 0xffffffff, "clrex%c"},
1245 {ARM_EXT_V6T2, 0xf3af8400, 0xffffff1f, "cpsie.w\t%7'a%6'i%5'f%X"},
1246 {ARM_EXT_V6T2, 0xf3af8600, 0xffffff1f, "cpsid.w\t%7'a%6'i%5'f%X"},
1247 {ARM_EXT_V6T2, 0xf3c08f00, 0xfff0ffff, "bxj%c\t%16-19r%x"},
1248 {ARM_EXT_V6T2, 0xe810c000, 0xffd0ffff, "rfedb%c\t%16-19r%21'!"},
1249 {ARM_EXT_V6T2, 0xe990c000, 0xffd0ffff, "rfeia%c\t%16-19r%21'!"},
1250 {ARM_EXT_V6T2, 0xf3ef8000, 0xffeff000, "mrs%c\t%8-11r, %D"},
1251 {ARM_EXT_V6T2, 0xf3af8100, 0xffffffe0, "cps\t#%0-4d%X"},
1252 {ARM_EXT_V6T2, 0xe8d0f000, 0xfff0fff0, "tbb%c\t[%16-19r, %0-3r]%x"},
1253 {ARM_EXT_V6T2, 0xe8d0f010, 0xfff0fff0, "tbh%c\t[%16-19r, %0-3r, lsl #1]%x"},
1254 {ARM_EXT_V6T2, 0xf3af8500, 0xffffff00, "cpsie\t%7'a%6'i%5'f, #%0-4d%X"},
1255 {ARM_EXT_V6T2, 0xf3af8700, 0xffffff00, "cpsid\t%7'a%6'i%5'f, #%0-4d%X"},
1256 {ARM_EXT_V6T2, 0xf3de8f00, 0xffffff00, "subs%c\tpc, lr, #%0-7d"},
1257 {ARM_EXT_V6T2, 0xf3808000, 0xffe0f000, "msr%c\t%C, %16-19r"},
1258 {ARM_EXT_V6T2, 0xe8500f00, 0xfff00fff, "ldrex%c\t%12-15r, [%16-19r]"},
1259 {ARM_EXT_V6T2, 0xe8d00f4f, 0xfff00fef, "ldrex%4?hb%c\t%12-15r, [%16-19r]"},
1260 {ARM_EXT_V6T2, 0xe800c000, 0xffd0ffe0, "srsdb%c\t%16-19r%21'!, #%0-4d"},
1261 {ARM_EXT_V6T2, 0xe980c000, 0xffd0ffe0, "srsia%c\t%16-19r%21'!, #%0-4d"},
1262 {ARM_EXT_V6T2, 0xfa0ff080, 0xfffff0c0, "sxth%c.w\t%8-11r, %0-3r%R"},
1263 {ARM_EXT_V6T2, 0xfa1ff080, 0xfffff0c0, "uxth%c.w\t%8-11r, %0-3r%R"},
1264 {ARM_EXT_V6T2, 0xfa2ff080, 0xfffff0c0, "sxtb16%c\t%8-11r, %0-3r%R"},
1265 {ARM_EXT_V6T2, 0xfa3ff080, 0xfffff0c0, "uxtb16%c\t%8-11r, %0-3r%R"},
1266 {ARM_EXT_V6T2, 0xfa4ff080, 0xfffff0c0, "sxtb%c.w\t%8-11r, %0-3r%R"},
1267 {ARM_EXT_V6T2, 0xfa5ff080, 0xfffff0c0, "uxtb%c.w\t%8-11r, %0-3r%R"},
1268 {ARM_EXT_V6T2, 0xe8400000, 0xfff000ff, "strex%c\t%8-11r, %12-15r, [%16-19r]"},
1269 {ARM_EXT_V6T2, 0xe8d0007f, 0xfff000ff, "ldrexd%c\t%12-15r, %8-11r, [%16-19r]"},
1270 {ARM_EXT_V6T2, 0xfa80f000, 0xfff0f0f0, "sadd8%c\t%8-11r, %16-19r, %0-3r"},
1271 {ARM_EXT_V6T2, 0xfa80f010, 0xfff0f0f0, "qadd8%c\t%8-11r, %16-19r, %0-3r"},
1272 {ARM_EXT_V6T2, 0xfa80f020, 0xfff0f0f0, "shadd8%c\t%8-11r, %16-19r, %0-3r"},
1273 {ARM_EXT_V6T2, 0xfa80f040, 0xfff0f0f0, "uadd8%c\t%8-11r, %16-19r, %0-3r"},
1274 {ARM_EXT_V6T2, 0xfa80f050, 0xfff0f0f0, "uqadd8%c\t%8-11r, %16-19r, %0-3r"},
1275 {ARM_EXT_V6T2, 0xfa80f060, 0xfff0f0f0, "uhadd8%c\t%8-11r, %16-19r, %0-3r"},
1276 {ARM_EXT_V6T2, 0xfa80f080, 0xfff0f0f0, "qadd%c\t%8-11r, %0-3r, %16-19r"},
1277 {ARM_EXT_V6T2, 0xfa80f090, 0xfff0f0f0, "qdadd%c\t%8-11r, %0-3r, %16-19r"},
1278 {ARM_EXT_V6T2, 0xfa80f0a0, 0xfff0f0f0, "qsub%c\t%8-11r, %0-3r, %16-19r"},
1279 {ARM_EXT_V6T2, 0xfa80f0b0, 0xfff0f0f0, "qdsub%c\t%8-11r, %0-3r, %16-19r"},
1280 {ARM_EXT_V6T2, 0xfa90f000, 0xfff0f0f0, "sadd16%c\t%8-11r, %16-19r, %0-3r"},
1281 {ARM_EXT_V6T2, 0xfa90f010, 0xfff0f0f0, "qadd16%c\t%8-11r, %16-19r, %0-3r"},
1282 {ARM_EXT_V6T2, 0xfa90f020, 0xfff0f0f0, "shadd16%c\t%8-11r, %16-19r, %0-3r"},
1283 {ARM_EXT_V6T2, 0xfa90f040, 0xfff0f0f0, "uadd16%c\t%8-11r, %16-19r, %0-3r"},
1284 {ARM_EXT_V6T2, 0xfa90f050, 0xfff0f0f0, "uqadd16%c\t%8-11r, %16-19r, %0-3r"},
1285 {ARM_EXT_V6T2, 0xfa90f060, 0xfff0f0f0, "uhadd16%c\t%8-11r, %16-19r, %0-3r"},
1286 {ARM_EXT_V6T2, 0xfa90f080, 0xfff0f0f0, "rev%c.w\t%8-11r, %16-19r"},
1287 {ARM_EXT_V6T2, 0xfa90f090, 0xfff0f0f0, "rev16%c.w\t%8-11r, %16-19r"},
1288 {ARM_EXT_V6T2, 0xfa90f0a0, 0xfff0f0f0, "rbit%c\t%8-11r, %16-19r"},
1289 {ARM_EXT_V6T2, 0xfa90f0b0, 0xfff0f0f0, "revsh%c.w\t%8-11r, %16-19r"},
1290 {ARM_EXT_V6T2, 0xfaa0f000, 0xfff0f0f0, "saddsubx%c\t%8-11r, %16-19r, %0-3r"},
1291 {ARM_EXT_V6T2, 0xfaa0f010, 0xfff0f0f0, "qaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1292 {ARM_EXT_V6T2, 0xfaa0f020, 0xfff0f0f0, "shaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1293 {ARM_EXT_V6T2, 0xfaa0f040, 0xfff0f0f0, "uaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1294 {ARM_EXT_V6T2, 0xfaa0f050, 0xfff0f0f0, "uqaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1295 {ARM_EXT_V6T2, 0xfaa0f060, 0xfff0f0f0, "uhaddsubx%c\t%8-11r, %16-19r, %0-3r"},
1296 {ARM_EXT_V6T2, 0xfaa0f080, 0xfff0f0f0, "sel%c\t%8-11r, %16-19r, %0-3r"},
1297 {ARM_EXT_V6T2, 0xfab0f080, 0xfff0f0f0, "clz%c\t%8-11r, %16-19r"},
1298 {ARM_EXT_V6T2, 0xfac0f000, 0xfff0f0f0, "ssub8%c\t%8-11r, %16-19r, %0-3r"},
1299 {ARM_EXT_V6T2, 0xfac0f010, 0xfff0f0f0, "qsub8%c\t%8-11r, %16-19r, %0-3r"},
1300 {ARM_EXT_V6T2, 0xfac0f020, 0xfff0f0f0, "shsub8%c\t%8-11r, %16-19r, %0-3r"},
1301 {ARM_EXT_V6T2, 0xfac0f040, 0xfff0f0f0, "usub8%c\t%8-11r, %16-19r, %0-3r"},
1302 {ARM_EXT_V6T2, 0xfac0f050, 0xfff0f0f0, "uqsub8%c\t%8-11r, %16-19r, %0-3r"},
1303 {ARM_EXT_V6T2, 0xfac0f060, 0xfff0f0f0, "uhsub8%c\t%8-11r, %16-19r, %0-3r"},
1304 {ARM_EXT_V6T2, 0xfad0f000, 0xfff0f0f0, "ssub16%c\t%8-11r, %16-19r, %0-3r"},
1305 {ARM_EXT_V6T2, 0xfad0f010, 0xfff0f0f0, "qsub16%c\t%8-11r, %16-19r, %0-3r"},
1306 {ARM_EXT_V6T2, 0xfad0f020, 0xfff0f0f0, "shsub16%c\t%8-11r, %16-19r, %0-3r"},
1307 {ARM_EXT_V6T2, 0xfad0f040, 0xfff0f0f0, "usub16%c\t%8-11r, %16-19r, %0-3r"},
1308 {ARM_EXT_V6T2, 0xfad0f050, 0xfff0f0f0, "uqsub16%c\t%8-11r, %16-19r, %0-3r"},
1309 {ARM_EXT_V6T2, 0xfad0f060, 0xfff0f0f0, "uhsub16%c\t%8-11r, %16-19r, %0-3r"},
1310 {ARM_EXT_V6T2, 0xfae0f000, 0xfff0f0f0, "ssubaddx%c\t%8-11r, %16-19r, %0-3r"},
1311 {ARM_EXT_V6T2, 0xfae0f010, 0xfff0f0f0, "qsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1312 {ARM_EXT_V6T2, 0xfae0f020, 0xfff0f0f0, "shsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1313 {ARM_EXT_V6T2, 0xfae0f040, 0xfff0f0f0, "usubaddx%c\t%8-11r, %16-19r, %0-3r"},
1314 {ARM_EXT_V6T2, 0xfae0f050, 0xfff0f0f0, "uqsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1315 {ARM_EXT_V6T2, 0xfae0f060, 0xfff0f0f0, "uhsubaddx%c\t%8-11r, %16-19r, %0-3r"},
1316 {ARM_EXT_V6T2, 0xfb00f000, 0xfff0f0f0, "mul%c.w\t%8-11r, %16-19r, %0-3r"},
1317 {ARM_EXT_V6T2, 0xfb70f000, 0xfff0f0f0, "usad8%c\t%8-11r, %16-19r, %0-3r"},
1318 {ARM_EXT_V6T2, 0xfa00f000, 0xffe0f0f0, "lsl%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1319 {ARM_EXT_V6T2, 0xfa20f000, 0xffe0f0f0, "lsr%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1320 {ARM_EXT_V6T2, 0xfa40f000, 0xffe0f0f0, "asr%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1321 {ARM_EXT_V6T2, 0xfa60f000, 0xffe0f0f0, "ror%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1322 {ARM_EXT_V6T2, 0xe8c00f40, 0xfff00fe0, "strex%4?hb%c\t%0-3r, %12-15r, [%16-19r]"},
1323 {ARM_EXT_V6T2, 0xf3200000, 0xfff0f0e0, "ssat16%c\t%8-11r, #%0-4d, %16-19r"},
1324 {ARM_EXT_V6T2, 0xf3a00000, 0xfff0f0e0, "usat16%c\t%8-11r, #%0-4d, %16-19r"},
1325 {ARM_EXT_V6T2, 0xfb20f000, 0xfff0f0e0, "smuad%4'x%c\t%8-11r, %16-19r, %0-3r"},
1326 {ARM_EXT_V6T2, 0xfb30f000, 0xfff0f0e0, "smulw%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1327 {ARM_EXT_V6T2, 0xfb40f000, 0xfff0f0e0, "smusd%4'x%c\t%8-11r, %16-19r, %0-3r"},
1328 {ARM_EXT_V6T2, 0xfb50f000, 0xfff0f0e0, "smmul%4'r%c\t%8-11r, %16-19r, %0-3r"},
1329 {ARM_EXT_V6T2, 0xfa00f080, 0xfff0f0c0, "sxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1330 {ARM_EXT_V6T2, 0xfa10f080, 0xfff0f0c0, "uxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1331 {ARM_EXT_V6T2, 0xfa20f080, 0xfff0f0c0, "sxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1332 {ARM_EXT_V6T2, 0xfa30f080, 0xfff0f0c0, "uxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1333 {ARM_EXT_V6T2, 0xfa40f080, 0xfff0f0c0, "sxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1334 {ARM_EXT_V6T2, 0xfa50f080, 0xfff0f0c0, "uxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1335 {ARM_EXT_V6T2, 0xfb10f000, 0xfff0f0c0, "smul%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1336 {ARM_EXT_V6T2, 0xf36f0000, 0xffff8020, "bfc%c\t%8-11r, %E"},
1337 {ARM_EXT_V6T2, 0xea100f00, 0xfff08f00, "tst%c.w\t%16-19r, %S"},
1338 {ARM_EXT_V6T2, 0xea900f00, 0xfff08f00, "teq%c\t%16-19r, %S"},
1339 {ARM_EXT_V6T2, 0xeb100f00, 0xfff08f00, "cmn%c.w\t%16-19r, %S"},
1340 {ARM_EXT_V6T2, 0xebb00f00, 0xfff08f00, "cmp%c.w\t%16-19r, %S"},
1341 {ARM_EXT_V6T2, 0xf0100f00, 0xfbf08f00, "tst%c.w\t%16-19r, %M"},
1342 {ARM_EXT_V6T2, 0xf0900f00, 0xfbf08f00, "teq%c\t%16-19r, %M"},
1343 {ARM_EXT_V6T2, 0xf1100f00, 0xfbf08f00, "cmn%c.w\t%16-19r, %M"},
1344 {ARM_EXT_V6T2, 0xf1b00f00, 0xfbf08f00, "cmp%c.w\t%16-19r, %M"},
1345 {ARM_EXT_V6T2, 0xea4f0000, 0xffef8000, "mov%20's%c.w\t%8-11r, %S"},
1346 {ARM_EXT_V6T2, 0xea6f0000, 0xffef8000, "mvn%20's%c.w\t%8-11r, %S"},
1347 {ARM_EXT_V6T2, 0xe8c00070, 0xfff000f0, "strexd%c\t%0-3r, %12-15r, %8-11r, [%16-19r]"},
1348 {ARM_EXT_V6T2, 0xfb000000, 0xfff000f0, "mla%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1349 {ARM_EXT_V6T2, 0xfb000010, 0xfff000f0, "mls%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1350 {ARM_EXT_V6T2, 0xfb700000, 0xfff000f0, "usada8%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1351 {ARM_EXT_V6T2, 0xfb800000, 0xfff000f0, "smull%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1352 {ARM_EXT_V6T2, 0xfba00000, 0xfff000f0, "umull%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1353 {ARM_EXT_V6T2, 0xfbc00000, 0xfff000f0, "smlal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1354 {ARM_EXT_V6T2, 0xfbe00000, 0xfff000f0, "umlal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1355 {ARM_EXT_V6T2, 0xfbe00060, 0xfff000f0, "umaal%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1356 {ARM_EXT_V6T2, 0xe8500f00, 0xfff00f00, "ldrex%c\t%12-15r, [%16-19r, #%0-7W]"},
1357 {ARM_EXT_V6T2, 0xf7f08000, 0xfff0f000, "smc%c\t%K"},
1358 {ARM_EXT_V6T2, 0xf04f0000, 0xfbef8000, "mov%20's%c.w\t%8-11r, %M"},
1359 {ARM_EXT_V6T2, 0xf06f0000, 0xfbef8000, "mvn%20's%c.w\t%8-11r, %M"},
1360 {ARM_EXT_V6T2, 0xf810f000, 0xff70f000, "pld%c\t%a"},
1361 {ARM_EXT_V6T2, 0xfb200000, 0xfff000e0, "smlad%4'x%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1362 {ARM_EXT_V6T2, 0xfb300000, 0xfff000e0, "smlaw%4?tb%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1363 {ARM_EXT_V6T2, 0xfb400000, 0xfff000e0, "smlsd%4'x%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1364 {ARM_EXT_V6T2, 0xfb500000, 0xfff000e0, "smmla%4'r%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1365 {ARM_EXT_V6T2, 0xfb600000, 0xfff000e0, "smmls%4'r%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1366 {ARM_EXT_V6T2, 0xfbc000c0, 0xfff000e0, "smlald%4'x%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1367 {ARM_EXT_V6T2, 0xfbd000c0, 0xfff000e0, "smlsld%4'x%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1368 {ARM_EXT_V6T2, 0xeac00000, 0xfff08030, "pkhbt%c\t%8-11r, %16-19r, %S"},
1369 {ARM_EXT_V6T2, 0xeac00020, 0xfff08030, "pkhtb%c\t%8-11r, %16-19r, %S"},
1370 {ARM_EXT_V6T2, 0xf3400000, 0xfff08020, "sbfx%c\t%8-11r, %16-19r, %F"},
1371 {ARM_EXT_V6T2, 0xf3c00000, 0xfff08020, "ubfx%c\t%8-11r, %16-19r, %F"},
1372 {ARM_EXT_V6T2, 0xf8000e00, 0xff900f00, "str%wt%c\t%12-15r, %a"},
1373 {ARM_EXT_V6T2, 0xfb100000, 0xfff000c0, "smla%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1374 {ARM_EXT_V6T2, 0xfbc00080, 0xfff000c0, "smlal%5?tb%4?tb%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1375 {ARM_EXT_V6T2, 0xf3600000, 0xfff08020, "bfi%c\t%8-11r, %16-19r, %E"},
1376 {ARM_EXT_V6T2, 0xf8100e00, 0xfe900f00, "ldr%wt%c\t%12-15r, %a"},
1377 {ARM_EXT_V6T2, 0xf3000000, 0xffd08020, "ssat%c\t%8-11r, #%0-4d, %16-19r%s"},
1378 {ARM_EXT_V6T2, 0xf3800000, 0xffd08020, "usat%c\t%8-11r, #%0-4d, %16-19r%s"},
1379 {ARM_EXT_V6T2, 0xf2000000, 0xfbf08000, "addw%c\t%8-11r, %16-19r, %I"},
1380 {ARM_EXT_V6T2, 0xf2400000, 0xfbf08000, "movw%c\t%8-11r, %J"},
1381 {ARM_EXT_V6T2, 0xf2a00000, 0xfbf08000, "subw%c\t%8-11r, %16-19r, %I"},
1382 {ARM_EXT_V6T2, 0xf2c00000, 0xfbf08000, "movt%c\t%8-11r, %J"},
1383 {ARM_EXT_V6T2, 0xea000000, 0xffe08000, "and%20's%c.w\t%8-11r, %16-19r, %S"},
1384 {ARM_EXT_V6T2, 0xea200000, 0xffe08000, "bic%20's%c.w\t%8-11r, %16-19r, %S"},
1385 {ARM_EXT_V6T2, 0xea400000, 0xffe08000, "orr%20's%c.w\t%8-11r, %16-19r, %S"},
1386 {ARM_EXT_V6T2, 0xea600000, 0xffe08000, "orn%20's%c\t%8-11r, %16-19r, %S"},
1387 {ARM_EXT_V6T2, 0xea800000, 0xffe08000, "eor%20's%c.w\t%8-11r, %16-19r, %S"},
1388 {ARM_EXT_V6T2, 0xeb000000, 0xffe08000, "add%20's%c.w\t%8-11r, %16-19r, %S"},
1389 {ARM_EXT_V6T2, 0xeb400000, 0xffe08000, "adc%20's%c.w\t%8-11r, %16-19r, %S"},
1390 {ARM_EXT_V6T2, 0xeb600000, 0xffe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %S"},
1391 {ARM_EXT_V6T2, 0xeba00000, 0xffe08000, "sub%20's%c.w\t%8-11r, %16-19r, %S"},
1392 {ARM_EXT_V6T2, 0xebc00000, 0xffe08000, "rsb%20's%c\t%8-11r, %16-19r, %S"},
1393 {ARM_EXT_V6T2, 0xe8400000, 0xfff00000, "strex%c\t%8-11r, %12-15r, [%16-19r, #%0-7W]"},
1394 {ARM_EXT_V6T2, 0xf0000000, 0xfbe08000, "and%20's%c.w\t%8-11r, %16-19r, %M"},
1395 {ARM_EXT_V6T2, 0xf0200000, 0xfbe08000, "bic%20's%c.w\t%8-11r, %16-19r, %M"},
1396 {ARM_EXT_V6T2, 0xf0400000, 0xfbe08000, "orr%20's%c.w\t%8-11r, %16-19r, %M"},
1397 {ARM_EXT_V6T2, 0xf0600000, 0xfbe08000, "orn%20's%c\t%8-11r, %16-19r, %M"},
1398 {ARM_EXT_V6T2, 0xf0800000, 0xfbe08000, "eor%20's%c.w\t%8-11r, %16-19r, %M"},
1399 {ARM_EXT_V6T2, 0xf1000000, 0xfbe08000, "add%20's%c.w\t%8-11r, %16-19r, %M"},
1400 {ARM_EXT_V6T2, 0xf1400000, 0xfbe08000, "adc%20's%c.w\t%8-11r, %16-19r, %M"},
1401 {ARM_EXT_V6T2, 0xf1600000, 0xfbe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %M"},
1402 {ARM_EXT_V6T2, 0xf1a00000, 0xfbe08000, "sub%20's%c.w\t%8-11r, %16-19r, %M"},
1403 {ARM_EXT_V6T2, 0xf1c00000, 0xfbe08000, "rsb%20's%c\t%8-11r, %16-19r, %M"},
1404 {ARM_EXT_V6T2, 0xe8800000, 0xffd00000, "stmia%c.w\t%16-19r%21'!, %m"},
1405 {ARM_EXT_V6T2, 0xe8900000, 0xffd00000, "ldmia%c.w\t%16-19r%21'!, %m"},
1406 {ARM_EXT_V6T2, 0xe9000000, 0xffd00000, "stmdb%c\t%16-19r%21'!, %m"},
1407 {ARM_EXT_V6T2, 0xe9100000, 0xffd00000, "ldmdb%c\t%16-19r%21'!, %m"},
1408 {ARM_EXT_V6T2, 0xe9c00000, 0xffd000ff, "strd%c\t%12-15r, %8-11r, [%16-19r]"},
1409 {ARM_EXT_V6T2, 0xe9d00000, 0xffd000ff, "ldrd%c\t%12-15r, %8-11r, [%16-19r]"},
1410 {ARM_EXT_V6T2, 0xe9400000, 0xff500000, "strd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1411 {ARM_EXT_V6T2, 0xe9500000, 0xff500000, "ldrd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1412 {ARM_EXT_V6T2, 0xe8600000, 0xff700000, "strd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1413 {ARM_EXT_V6T2, 0xe8700000, 0xff700000, "ldrd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1414 {ARM_EXT_V6T2, 0xf8000000, 0xff100000, "str%w%c.w\t%12-15r, %a"},
1415 {ARM_EXT_V6T2, 0xf8100000, 0xfe100000, "ldr%w%c.w\t%12-15r, %a"},
1416
1417 /* Filter out Bcc with cond=E or F, which are used for other instructions. */
1418 {ARM_EXT_V6T2, 0xf3c08000, 0xfbc0d000, "undefined (bcc, cond=0xF)"},
1419 {ARM_EXT_V6T2, 0xf3808000, 0xfbc0d000, "undefined (bcc, cond=0xE)"},
1420 {ARM_EXT_V6T2, 0xf0008000, 0xf800d000, "b%22-25c.w\t%b%X"},
1421 {ARM_EXT_V6T2, 0xf0009000, 0xf800d000, "b%c.w\t%B%x"},
1422
1423 /* These have been 32-bit since the invention of Thumb. */
1424 {ARM_EXT_V4T, 0xf000c000, 0xf800d000, "blx%c\t%B%x"},
1425 {ARM_EXT_V4T, 0xf000d000, 0xf800d000, "bl%c\t%B%x"},
1426
1427 /* Fallback. */
1428 {ARM_EXT_V1, 0x00000000, 0x00000000, "undefined"},
1429 {0, 0, 0, 0}
1430 };
1431
1432 static const char *const arm_conditional[] =
1433 {"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
1434 "hi", "ls", "ge", "lt", "gt", "le", "al", "<und>", ""};
1435
1436 static const char *const arm_fp_const[] =
1437 {"0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0"};
1438
1439 static const char *const arm_shift[] =
1440 {"lsl", "lsr", "asr", "ror"};
1441
1442 typedef struct
1443 {
1444 const char *name;
1445 const char *description;
1446 const char *reg_names[16];
1447 }
1448 arm_regname;
1449
1450 static const arm_regname regnames[] =
1451 {
1452 { "raw" , "Select raw register names",
1453 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"}},
1454 { "gcc", "Select register names used by GCC",
1455 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "sl", "fp", "ip", "sp", "lr", "pc" }},
1456 { "std", "Select register names used in ARM's ISA documentation",
1457 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc" }},
1458 { "apcs", "Select register names used in the APCS",
1459 { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "sl", "fp", "ip", "sp", "lr", "pc" }},
1460 { "atpcs", "Select register names used in the ATPCS",
1461 { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "IP", "SP", "LR", "PC" }},
1462 { "special-atpcs", "Select special register names used in the ATPCS",
1463 { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "WR", "v5", "SB", "SL", "FP", "IP", "SP", "LR", "PC" }},
1464 };
1465
1466 static const char *const iwmmxt_wwnames[] =
1467 {"b", "h", "w", "d"};
1468
1469 static const char *const iwmmxt_wwssnames[] =
1470 {"b", "bus", "bc", "bss",
1471 "h", "hus", "hc", "hss",
1472 "w", "wus", "wc", "wss",
1473 "d", "dus", "dc", "dss"
1474 };
1475
1476 static const char *const iwmmxt_regnames[] =
1477 { "wr0", "wr1", "wr2", "wr3", "wr4", "wr5", "wr6", "wr7",
1478 "wr8", "wr9", "wr10", "wr11", "wr12", "wr13", "wr14", "wr15"
1479 };
1480
1481 static const char *const iwmmxt_cregnames[] =
1482 { "wcid", "wcon", "wcssf", "wcasf", "reserved", "reserved", "reserved", "reserved",
1483 "wcgr0", "wcgr1", "wcgr2", "wcgr3", "reserved", "reserved", "reserved", "reserved"
1484 };
1485
1486 /* Default to GCC register name set. */
1487 static unsigned int regname_selected = 1;
1488
1489 #define NUM_ARM_REGNAMES NUM_ELEM (regnames)
1490 #define arm_regnames regnames[regname_selected].reg_names
1491
1492 static bfd_boolean force_thumb = FALSE;
1493
1494 /* Current IT instruction state. This contains the same state as the IT
1495 bits in the CPSR. */
1496 static unsigned int ifthen_state;
1497 /* IT state for the next instruction. */
1498 static unsigned int ifthen_next_state;
1499 /* The address of the insn for which the IT state is valid. */
1500 static bfd_vma ifthen_address;
1501 #define IFTHEN_COND ((ifthen_state >> 4) & 0xf)
1502
1503 /* Cached mapping symbol state. */
1504 enum map_type {
1505 MAP_ARM,
1506 MAP_THUMB,
1507 MAP_DATA
1508 };
1509
1510 enum map_type last_type;
1511 int last_mapping_sym = -1;
1512 bfd_vma last_mapping_addr = 0;
1513
1514
1515 /* Functions. */
1516 int
get_arm_regname_num_options(void)1517 get_arm_regname_num_options (void)
1518 {
1519 return NUM_ARM_REGNAMES;
1520 }
1521
1522 int
set_arm_regname_option(int option)1523 set_arm_regname_option (int option)
1524 {
1525 int old = regname_selected;
1526 regname_selected = option;
1527 return old;
1528 }
1529
1530 int
get_arm_regnames(int option,const char ** setname,const char ** setdescription,const char * const ** register_names)1531 get_arm_regnames (int option, const char **setname, const char **setdescription,
1532 const char *const **register_names)
1533 {
1534 *setname = regnames[option].name;
1535 *setdescription = regnames[option].description;
1536 *register_names = regnames[option].reg_names;
1537 return 16;
1538 }
1539
1540 /* Decode a bitfield of the form matching regexp (N(-N)?,)*N(-N)?.
1541 Returns pointer to following character of the format string and
1542 fills in *VALUEP and *WIDTHP with the extracted value and number of
1543 bits extracted. WIDTHP can be NULL. */
1544
1545 static const char *
arm_decode_bitfield(const char * ptr,unsigned long insn,unsigned long * valuep,int * widthp)1546 arm_decode_bitfield (const char *ptr, unsigned long insn,
1547 unsigned long *valuep, int *widthp)
1548 {
1549 unsigned long value = 0;
1550 int width = 0;
1551
1552 do
1553 {
1554 int start, end;
1555 int bits;
1556
1557 for (start = 0; *ptr >= '0' && *ptr <= '9'; ptr++)
1558 start = start * 10 + *ptr - '0';
1559 if (*ptr == '-')
1560 for (end = 0, ptr++; *ptr >= '0' && *ptr <= '9'; ptr++)
1561 end = end * 10 + *ptr - '0';
1562 else
1563 end = start;
1564 bits = end - start;
1565 if (bits < 0)
1566 abort ();
1567 value |= ((insn >> start) & ((2ul << bits) - 1)) << width;
1568 width += bits + 1;
1569 }
1570 while (*ptr++ == ',');
1571 *valuep = value;
1572 if (widthp)
1573 *widthp = width;
1574 return ptr - 1;
1575 }
1576
1577 static void
arm_decode_shift(long given,fprintf_ftype func,void * stream,int print_shift)1578 arm_decode_shift (long given, fprintf_ftype func, void *stream,
1579 int print_shift)
1580 {
1581 func (stream, "%s", arm_regnames[given & 0xf]);
1582
1583 if ((given & 0xff0) != 0)
1584 {
1585 if ((given & 0x10) == 0)
1586 {
1587 int amount = (given & 0xf80) >> 7;
1588 int shift = (given & 0x60) >> 5;
1589
1590 if (amount == 0)
1591 {
1592 if (shift == 3)
1593 {
1594 func (stream, ", rrx");
1595 return;
1596 }
1597
1598 amount = 32;
1599 }
1600
1601 if (print_shift)
1602 func (stream, ", %s #%d", arm_shift[shift], amount);
1603 else
1604 func (stream, ", #%d", amount);
1605 }
1606 else if (print_shift)
1607 func (stream, ", %s %s", arm_shift[(given & 0x60) >> 5],
1608 arm_regnames[(given & 0xf00) >> 8]);
1609 else
1610 func (stream, ", %s", arm_regnames[(given & 0xf00) >> 8]);
1611 }
1612 }
1613
1614 /* Print one coprocessor instruction on INFO->STREAM.
1615 Return TRUE if the instuction matched, FALSE if this is not a
1616 recognised coprocessor instruction. */
1617
1618 static bfd_boolean
print_insn_coprocessor(bfd_vma pc,struct disassemble_info * info,long given,bfd_boolean thumb)1619 print_insn_coprocessor (bfd_vma pc, struct disassemble_info *info, long given,
1620 bfd_boolean thumb)
1621 {
1622 const struct opcode32 *insn;
1623 void *stream = info->stream;
1624 fprintf_ftype func = info->fprintf_func;
1625 unsigned long mask;
1626 unsigned long value;
1627 int cond;
1628
1629 for (insn = coprocessor_opcodes; insn->assembler; insn++)
1630 {
1631 if (insn->value == FIRST_IWMMXT_INSN
1632 && info->mach != bfd_mach_arm_XScale
1633 && info->mach != bfd_mach_arm_iWMMXt
1634 && info->mach != bfd_mach_arm_iWMMXt2)
1635 insn = insn + IWMMXT_INSN_COUNT;
1636
1637 mask = insn->mask;
1638 value = insn->value;
1639 if (thumb)
1640 {
1641 /* The high 4 bits are 0xe for Arm conditional instructions, and
1642 0xe for arm unconditional instructions. The rest of the
1643 encoding is the same. */
1644 mask |= 0xf0000000;
1645 value |= 0xe0000000;
1646 if (ifthen_state)
1647 cond = IFTHEN_COND;
1648 else
1649 cond = 16;
1650 }
1651 else
1652 {
1653 /* Only match unconditional instuctions against unconditional
1654 patterns. */
1655 if ((given & 0xf0000000) == 0xf0000000)
1656 {
1657 mask |= 0xf0000000;
1658 cond = 16;
1659 }
1660 else
1661 {
1662 cond = (given >> 28) & 0xf;
1663 if (cond == 0xe)
1664 cond = 16;
1665 }
1666 }
1667 if ((given & mask) == value)
1668 {
1669 const char *c;
1670
1671 for (c = insn->assembler; *c; c++)
1672 {
1673 if (*c == '%')
1674 {
1675 switch (*++c)
1676 {
1677 case '%':
1678 func (stream, "%%");
1679 break;
1680
1681 case 'A':
1682 func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
1683
1684 if ((given & (1 << 24)) != 0)
1685 {
1686 int offset = given & 0xff;
1687
1688 if (offset)
1689 func (stream, ", #%s%d]%s",
1690 ((given & 0x00800000) == 0 ? "-" : ""),
1691 offset * 4,
1692 ((given & 0x00200000) != 0 ? "!" : ""));
1693 else
1694 func (stream, "]");
1695 }
1696 else
1697 {
1698 int offset = given & 0xff;
1699
1700 func (stream, "]");
1701
1702 if (given & (1 << 21))
1703 {
1704 if (offset)
1705 func (stream, ", #%s%d",
1706 ((given & 0x00800000) == 0 ? "-" : ""),
1707 offset * 4);
1708 }
1709 else
1710 func (stream, ", {%d}", offset);
1711 }
1712 break;
1713
1714 case 'B':
1715 {
1716 int regno = ((given >> 12) & 0xf) | ((given >> (22 - 4)) & 0x10);
1717 int offset = (given >> 1) & 0x3f;
1718
1719 if (offset == 1)
1720 func (stream, "{d%d}", regno);
1721 else if (regno + offset > 32)
1722 func (stream, "{d%d-<overflow reg d%d>}", regno, regno + offset - 1);
1723 else
1724 func (stream, "{d%d-d%d}", regno, regno + offset - 1);
1725 }
1726 break;
1727
1728 case 'C':
1729 {
1730 int rn = (given >> 16) & 0xf;
1731 int offset = (given & 0xff) * 4;
1732 int add = (given >> 23) & 1;
1733
1734 func (stream, "[%s", arm_regnames[rn]);
1735
1736 if (offset)
1737 {
1738 if (!add)
1739 offset = -offset;
1740 func (stream, ", #%d", offset);
1741 }
1742 func (stream, "]");
1743 if (rn == 15)
1744 {
1745 func (stream, "\t; ");
1746 /* FIXME: Unsure if info->bytes_per_chunk is the
1747 right thing to use here. */
1748 info->print_address_func (offset + pc
1749 + info->bytes_per_chunk * 2, info);
1750 }
1751 }
1752 break;
1753
1754 case 'c':
1755 func (stream, "%s", arm_conditional[cond]);
1756 break;
1757
1758 case 'I':
1759 /* Print a Cirrus/DSP shift immediate. */
1760 /* Immediates are 7bit signed ints with bits 0..3 in
1761 bits 0..3 of opcode and bits 4..6 in bits 5..7
1762 of opcode. */
1763 {
1764 int imm;
1765
1766 imm = (given & 0xf) | ((given & 0xe0) >> 1);
1767
1768 /* Is ``imm'' a negative number? */
1769 if (imm & 0x40)
1770 imm |= -(1 << 7);
1771
1772 func (stream, "%d", imm);
1773 }
1774
1775 break;
1776
1777 case 'F':
1778 switch (given & 0x00408000)
1779 {
1780 case 0:
1781 func (stream, "4");
1782 break;
1783 case 0x8000:
1784 func (stream, "1");
1785 break;
1786 case 0x00400000:
1787 func (stream, "2");
1788 break;
1789 default:
1790 func (stream, "3");
1791 }
1792 break;
1793
1794 case 'P':
1795 switch (given & 0x00080080)
1796 {
1797 case 0:
1798 func (stream, "s");
1799 break;
1800 case 0x80:
1801 func (stream, "d");
1802 break;
1803 case 0x00080000:
1804 func (stream, "e");
1805 break;
1806 default:
1807 func (stream, _("<illegal precision>"));
1808 break;
1809 }
1810 break;
1811 case 'Q':
1812 switch (given & 0x00408000)
1813 {
1814 case 0:
1815 func (stream, "s");
1816 break;
1817 case 0x8000:
1818 func (stream, "d");
1819 break;
1820 case 0x00400000:
1821 func (stream, "e");
1822 break;
1823 default:
1824 func (stream, "p");
1825 break;
1826 }
1827 break;
1828 case 'R':
1829 switch (given & 0x60)
1830 {
1831 case 0:
1832 break;
1833 case 0x20:
1834 func (stream, "p");
1835 break;
1836 case 0x40:
1837 func (stream, "m");
1838 break;
1839 default:
1840 func (stream, "z");
1841 break;
1842 }
1843 break;
1844
1845 case '0': case '1': case '2': case '3': case '4':
1846 case '5': case '6': case '7': case '8': case '9':
1847 {
1848 int width;
1849 unsigned long value;
1850
1851 c = arm_decode_bitfield (c, given, &value, &width);
1852
1853 switch (*c)
1854 {
1855 case 'r':
1856 func (stream, "%s", arm_regnames[value]);
1857 break;
1858 case 'D':
1859 func (stream, "d%ld", value);
1860 break;
1861 case 'Q':
1862 if (value & 1)
1863 func (stream, "<illegal reg q%ld.5>", value >> 1);
1864 else
1865 func (stream, "q%ld", value >> 1);
1866 break;
1867 case 'd':
1868 func (stream, "%ld", value);
1869 break;
1870 case 'k':
1871 {
1872 int from = (given & (1 << 7)) ? 32 : 16;
1873 func (stream, "%ld", from - value);
1874 }
1875 break;
1876
1877 case 'f':
1878 if (value > 7)
1879 func (stream, "#%s", arm_fp_const[value & 7]);
1880 else
1881 func (stream, "f%ld", value);
1882 break;
1883
1884 case 'w':
1885 if (width == 2)
1886 func (stream, "%s", iwmmxt_wwnames[value]);
1887 else
1888 func (stream, "%s", iwmmxt_wwssnames[value]);
1889 break;
1890
1891 case 'g':
1892 func (stream, "%s", iwmmxt_regnames[value]);
1893 break;
1894 case 'G':
1895 func (stream, "%s", iwmmxt_cregnames[value]);
1896 break;
1897
1898 case 'x':
1899 func (stream, "0x%lx", value);
1900 break;
1901
1902 case '`':
1903 c++;
1904 if (value == 0)
1905 func (stream, "%c", *c);
1906 break;
1907 case '\'':
1908 c++;
1909 if (value == ((1ul << width) - 1))
1910 func (stream, "%c", *c);
1911 break;
1912 case '?':
1913 func (stream, "%c", c[(1 << width) - (int)value]);
1914 c += 1 << width;
1915 break;
1916 default:
1917 abort ();
1918 }
1919 break;
1920
1921 case 'y':
1922 case 'z':
1923 {
1924 int single = *c++ == 'y';
1925 int regno;
1926
1927 switch (*c)
1928 {
1929 case '4': /* Sm pair */
1930 func (stream, "{");
1931 /* Fall through. */
1932 case '0': /* Sm, Dm */
1933 regno = given & 0x0000000f;
1934 if (single)
1935 {
1936 regno <<= 1;
1937 regno += (given >> 5) & 1;
1938 }
1939 else
1940 regno += ((given >> 5) & 1) << 4;
1941 break;
1942
1943 case '1': /* Sd, Dd */
1944 regno = (given >> 12) & 0x0000000f;
1945 if (single)
1946 {
1947 regno <<= 1;
1948 regno += (given >> 22) & 1;
1949 }
1950 else
1951 regno += ((given >> 22) & 1) << 4;
1952 break;
1953
1954 case '2': /* Sn, Dn */
1955 regno = (given >> 16) & 0x0000000f;
1956 if (single)
1957 {
1958 regno <<= 1;
1959 regno += (given >> 7) & 1;
1960 }
1961 else
1962 regno += ((given >> 7) & 1) << 4;
1963 break;
1964
1965 case '3': /* List */
1966 func (stream, "{");
1967 regno = (given >> 12) & 0x0000000f;
1968 if (single)
1969 {
1970 regno <<= 1;
1971 regno += (given >> 22) & 1;
1972 }
1973 else
1974 regno += ((given >> 22) & 1) << 4;
1975 break;
1976
1977 default:
1978 abort ();
1979 }
1980
1981 func (stream, "%c%d", single ? 's' : 'd', regno);
1982
1983 if (*c == '3')
1984 {
1985 int count = given & 0xff;
1986
1987 if (single == 0)
1988 count >>= 1;
1989
1990 if (--count)
1991 {
1992 func (stream, "-%c%d",
1993 single ? 's' : 'd',
1994 regno + count);
1995 }
1996
1997 func (stream, "}");
1998 }
1999 else if (*c == '4')
2000 func (stream, ", %c%d}", single ? 's' : 'd',
2001 regno + 1);
2002 }
2003 break;
2004
2005 case 'L':
2006 switch (given & 0x00400100)
2007 {
2008 case 0x00000000: func (stream, "b"); break;
2009 case 0x00400000: func (stream, "h"); break;
2010 case 0x00000100: func (stream, "w"); break;
2011 case 0x00400100: func (stream, "d"); break;
2012 default:
2013 break;
2014 }
2015 break;
2016
2017 case 'Z':
2018 {
2019 int value;
2020 /* given (20, 23) | given (0, 3) */
2021 value = ((given >> 16) & 0xf0) | (given & 0xf);
2022 func (stream, "%d", value);
2023 }
2024 break;
2025
2026 case 'l':
2027 /* This is like the 'A' operator, except that if
2028 the width field "M" is zero, then the offset is
2029 *not* multiplied by four. */
2030 {
2031 int offset = given & 0xff;
2032 int multiplier = (given & 0x00000100) ? 4 : 1;
2033
2034 func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
2035
2036 if (offset)
2037 {
2038 if ((given & 0x01000000) != 0)
2039 func (stream, ", #%s%d]%s",
2040 ((given & 0x00800000) == 0 ? "-" : ""),
2041 offset * multiplier,
2042 ((given & 0x00200000) != 0 ? "!" : ""));
2043 else
2044 func (stream, "], #%s%d",
2045 ((given & 0x00800000) == 0 ? "-" : ""),
2046 offset * multiplier);
2047 }
2048 else
2049 func (stream, "]");
2050 }
2051 break;
2052
2053 case 'r':
2054 {
2055 int imm4 = (given >> 4) & 0xf;
2056 int puw_bits = ((given >> 22) & 6) | ((given >> 21) & 1);
2057 int ubit = (given >> 23) & 1;
2058 const char *rm = arm_regnames [given & 0xf];
2059 const char *rn = arm_regnames [(given >> 16) & 0xf];
2060
2061 switch (puw_bits)
2062 {
2063 case 1:
2064 /* fall through */
2065 case 3:
2066 func (stream, "[%s], %c%s", rn, ubit ? '+' : '-', rm);
2067 if (imm4)
2068 func (stream, ", lsl #%d", imm4);
2069 break;
2070
2071 case 4:
2072 /* fall through */
2073 case 5:
2074 /* fall through */
2075 case 6:
2076 /* fall through */
2077 case 7:
2078 func (stream, "[%s, %c%s", rn, ubit ? '+' : '-', rm);
2079 if (imm4 > 0)
2080 func (stream, ", lsl #%d", imm4);
2081 func (stream, "]");
2082 if (puw_bits == 5 || puw_bits == 7)
2083 func (stream, "!");
2084 break;
2085
2086 default:
2087 func (stream, "INVALID");
2088 }
2089 }
2090 break;
2091
2092 case 'i':
2093 {
2094 long imm5;
2095 imm5 = ((given & 0x100) >> 4) | (given & 0xf);
2096 func (stream, "%ld", (imm5 == 0) ? 32 : imm5);
2097 }
2098 break;
2099
2100 default:
2101 abort ();
2102 }
2103 }
2104 }
2105 else
2106 func (stream, "%c", *c);
2107 }
2108 return TRUE;
2109 }
2110 }
2111 return FALSE;
2112 }
2113
2114 static void
print_arm_address(bfd_vma pc,struct disassemble_info * info,long given)2115 print_arm_address (bfd_vma pc, struct disassemble_info *info, long given)
2116 {
2117 void *stream = info->stream;
2118 fprintf_ftype func = info->fprintf_func;
2119
2120 if (((given & 0x000f0000) == 0x000f0000)
2121 && ((given & 0x02000000) == 0))
2122 {
2123 int offset = given & 0xfff;
2124
2125 func (stream, "[pc");
2126
2127 if (given & 0x01000000)
2128 {
2129 if ((given & 0x00800000) == 0)
2130 offset = - offset;
2131
2132 /* Pre-indexed. */
2133 func (stream, ", #%d]", offset);
2134
2135 offset += pc + 8;
2136
2137 /* Cope with the possibility of write-back
2138 being used. Probably a very dangerous thing
2139 for the programmer to do, but who are we to
2140 argue ? */
2141 if (given & 0x00200000)
2142 func (stream, "!");
2143 }
2144 else
2145 {
2146 /* Post indexed. */
2147 func (stream, "], #%d", offset);
2148
2149 /* ie ignore the offset. */
2150 offset = pc + 8;
2151 }
2152
2153 func (stream, "\t; ");
2154 info->print_address_func (offset, info);
2155 }
2156 else
2157 {
2158 func (stream, "[%s",
2159 arm_regnames[(given >> 16) & 0xf]);
2160 if ((given & 0x01000000) != 0)
2161 {
2162 if ((given & 0x02000000) == 0)
2163 {
2164 int offset = given & 0xfff;
2165 if (offset)
2166 func (stream, ", #%s%d",
2167 (((given & 0x00800000) == 0)
2168 ? "-" : ""), offset);
2169 }
2170 else
2171 {
2172 func (stream, ", %s",
2173 (((given & 0x00800000) == 0)
2174 ? "-" : ""));
2175 arm_decode_shift (given, func, stream, 1);
2176 }
2177
2178 func (stream, "]%s",
2179 ((given & 0x00200000) != 0) ? "!" : "");
2180 }
2181 else
2182 {
2183 if ((given & 0x02000000) == 0)
2184 {
2185 int offset = given & 0xfff;
2186 if (offset)
2187 func (stream, "], #%s%d",
2188 (((given & 0x00800000) == 0)
2189 ? "-" : ""), offset);
2190 else
2191 func (stream, "]");
2192 }
2193 else
2194 {
2195 func (stream, "], %s",
2196 (((given & 0x00800000) == 0)
2197 ? "-" : ""));
2198 arm_decode_shift (given, func, stream, 1);
2199 }
2200 }
2201 }
2202 }
2203
2204 /* Print one neon instruction on INFO->STREAM.
2205 Return TRUE if the instuction matched, FALSE if this is not a
2206 recognised neon instruction. */
2207
2208 static bfd_boolean
print_insn_neon(struct disassemble_info * info,long given,bfd_boolean thumb)2209 print_insn_neon (struct disassemble_info *info, long given, bfd_boolean thumb)
2210 {
2211 const struct opcode32 *insn;
2212 void *stream = info->stream;
2213 fprintf_ftype func = info->fprintf_func;
2214
2215 if (thumb)
2216 {
2217 if ((given & 0xef000000) == 0xef000000)
2218 {
2219 /* move bit 28 to bit 24 to translate Thumb2 to ARM encoding. */
2220 unsigned long bit28 = given & (1 << 28);
2221
2222 given &= 0x00ffffff;
2223 if (bit28)
2224 given |= 0xf3000000;
2225 else
2226 given |= 0xf2000000;
2227 }
2228 else if ((given & 0xff000000) == 0xf9000000)
2229 given ^= 0xf9000000 ^ 0xf4000000;
2230 else
2231 return FALSE;
2232 }
2233
2234 for (insn = neon_opcodes; insn->assembler; insn++)
2235 {
2236 if ((given & insn->mask) == insn->value)
2237 {
2238 const char *c;
2239
2240 for (c = insn->assembler; *c; c++)
2241 {
2242 if (*c == '%')
2243 {
2244 switch (*++c)
2245 {
2246 case '%':
2247 func (stream, "%%");
2248 break;
2249
2250 case 'c':
2251 if (thumb && ifthen_state)
2252 func (stream, "%s", arm_conditional[IFTHEN_COND]);
2253 break;
2254
2255 case 'A':
2256 {
2257 static const unsigned char enc[16] =
2258 {
2259 0x4, 0x14, /* st4 0,1 */
2260 0x4, /* st1 2 */
2261 0x4, /* st2 3 */
2262 0x3, /* st3 4 */
2263 0x13, /* st3 5 */
2264 0x3, /* st1 6 */
2265 0x1, /* st1 7 */
2266 0x2, /* st2 8 */
2267 0x12, /* st2 9 */
2268 0x2, /* st1 10 */
2269 0, 0, 0, 0, 0
2270 };
2271 int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2272 int rn = ((given >> 16) & 0xf);
2273 int rm = ((given >> 0) & 0xf);
2274 int align = ((given >> 4) & 0x3);
2275 int type = ((given >> 8) & 0xf);
2276 int n = enc[type] & 0xf;
2277 int stride = (enc[type] >> 4) + 1;
2278 int ix;
2279
2280 func (stream, "{");
2281 if (stride > 1)
2282 for (ix = 0; ix != n; ix++)
2283 func (stream, "%sd%d", ix ? "," : "", rd + ix * stride);
2284 else if (n == 1)
2285 func (stream, "d%d", rd);
2286 else
2287 func (stream, "d%d-d%d", rd, rd + n - 1);
2288 func (stream, "}, [%s", arm_regnames[rn]);
2289 if (align)
2290 func (stream, ", :%d", 32 << align);
2291 func (stream, "]");
2292 if (rm == 0xd)
2293 func (stream, "!");
2294 else if (rm != 0xf)
2295 func (stream, ", %s", arm_regnames[rm]);
2296 }
2297 break;
2298
2299 case 'B':
2300 {
2301 int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2302 int rn = ((given >> 16) & 0xf);
2303 int rm = ((given >> 0) & 0xf);
2304 int idx_align = ((given >> 4) & 0xf);
2305 int align = 0;
2306 int size = ((given >> 10) & 0x3);
2307 int idx = idx_align >> (size + 1);
2308 int length = ((given >> 8) & 3) + 1;
2309 int stride = 1;
2310 int i;
2311
2312 if (length > 1 && size > 0)
2313 stride = (idx_align & (1 << size)) ? 2 : 1;
2314
2315 switch (length)
2316 {
2317 case 1:
2318 {
2319 int amask = (1 << size) - 1;
2320 if ((idx_align & (1 << size)) != 0)
2321 return FALSE;
2322 if (size > 0)
2323 {
2324 if ((idx_align & amask) == amask)
2325 align = 8 << size;
2326 else if ((idx_align & amask) != 0)
2327 return FALSE;
2328 }
2329 }
2330 break;
2331
2332 case 2:
2333 if (size == 2 && (idx_align & 2) != 0)
2334 return FALSE;
2335 align = (idx_align & 1) ? 16 << size : 0;
2336 break;
2337
2338 case 3:
2339 if ((size == 2 && (idx_align & 3) != 0)
2340 || (idx_align & 1) != 0)
2341 return FALSE;
2342 break;
2343
2344 case 4:
2345 if (size == 2)
2346 {
2347 if ((idx_align & 3) == 3)
2348 return FALSE;
2349 align = (idx_align & 3) * 64;
2350 }
2351 else
2352 align = (idx_align & 1) ? 32 << size : 0;
2353 break;
2354
2355 default:
2356 abort ();
2357 }
2358
2359 func (stream, "{");
2360 for (i = 0; i < length; i++)
2361 func (stream, "%sd%d[%d]", (i == 0) ? "" : ",",
2362 rd + i * stride, idx);
2363 func (stream, "}, [%s", arm_regnames[rn]);
2364 if (align)
2365 func (stream, ", :%d", align);
2366 func (stream, "]");
2367 if (rm == 0xd)
2368 func (stream, "!");
2369 else if (rm != 0xf)
2370 func (stream, ", %s", arm_regnames[rm]);
2371 }
2372 break;
2373
2374 case 'C':
2375 {
2376 int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2377 int rn = ((given >> 16) & 0xf);
2378 int rm = ((given >> 0) & 0xf);
2379 int align = ((given >> 4) & 0x1);
2380 int size = ((given >> 6) & 0x3);
2381 int type = ((given >> 8) & 0x3);
2382 int n = type + 1;
2383 int stride = ((given >> 5) & 0x1);
2384 int ix;
2385
2386 if (stride && (n == 1))
2387 n++;
2388 else
2389 stride++;
2390
2391 func (stream, "{");
2392 if (stride > 1)
2393 for (ix = 0; ix != n; ix++)
2394 func (stream, "%sd%d[]", ix ? "," : "", rd + ix * stride);
2395 else if (n == 1)
2396 func (stream, "d%d[]", rd);
2397 else
2398 func (stream, "d%d[]-d%d[]", rd, rd + n - 1);
2399 func (stream, "}, [%s", arm_regnames[rn]);
2400 if (align)
2401 {
2402 int align = (8 * (type + 1)) << size;
2403 if (type == 3)
2404 align = (size > 1) ? align >> 1 : align;
2405 if (type == 2 || (type == 0 && !size))
2406 func (stream, ", :<bad align %d>", align);
2407 else
2408 func (stream, ", :%d", align);
2409 }
2410 func (stream, "]");
2411 if (rm == 0xd)
2412 func (stream, "!");
2413 else if (rm != 0xf)
2414 func (stream, ", %s", arm_regnames[rm]);
2415 }
2416 break;
2417
2418 case 'D':
2419 {
2420 int raw_reg = (given & 0xf) | ((given >> 1) & 0x10);
2421 int size = (given >> 20) & 3;
2422 int reg = raw_reg & ((4 << size) - 1);
2423 int ix = raw_reg >> size >> 2;
2424
2425 func (stream, "d%d[%d]", reg, ix);
2426 }
2427 break;
2428
2429 case 'E':
2430 /* Neon encoded constant for mov, mvn, vorr, vbic */
2431 {
2432 int bits = 0;
2433 int cmode = (given >> 8) & 0xf;
2434 int op = (given >> 5) & 0x1;
2435 unsigned long value = 0, hival = 0;
2436 unsigned shift;
2437 int size = 0;
2438 int isfloat = 0;
2439
2440 bits |= ((given >> 24) & 1) << 7;
2441 bits |= ((given >> 16) & 7) << 4;
2442 bits |= ((given >> 0) & 15) << 0;
2443
2444 if (cmode < 8)
2445 {
2446 shift = (cmode >> 1) & 3;
2447 value = (unsigned long)bits << (8 * shift);
2448 size = 32;
2449 }
2450 else if (cmode < 12)
2451 {
2452 shift = (cmode >> 1) & 1;
2453 value = (unsigned long)bits << (8 * shift);
2454 size = 16;
2455 }
2456 else if (cmode < 14)
2457 {
2458 shift = (cmode & 1) + 1;
2459 value = (unsigned long)bits << (8 * shift);
2460 value |= (1ul << (8 * shift)) - 1;
2461 size = 32;
2462 }
2463 else if (cmode == 14)
2464 {
2465 if (op)
2466 {
2467 /* bit replication into bytes */
2468 int ix;
2469 unsigned long mask;
2470
2471 value = 0;
2472 hival = 0;
2473 for (ix = 7; ix >= 0; ix--)
2474 {
2475 mask = ((bits >> ix) & 1) ? 0xff : 0;
2476 if (ix <= 3)
2477 value = (value << 8) | mask;
2478 else
2479 hival = (hival << 8) | mask;
2480 }
2481 size = 64;
2482 }
2483 else
2484 {
2485 /* byte replication */
2486 value = (unsigned long)bits;
2487 size = 8;
2488 }
2489 }
2490 else if (!op)
2491 {
2492 /* floating point encoding */
2493 int tmp;
2494
2495 value = (unsigned long)(bits & 0x7f) << 19;
2496 value |= (unsigned long)(bits & 0x80) << 24;
2497 tmp = bits & 0x40 ? 0x3c : 0x40;
2498 value |= (unsigned long)tmp << 24;
2499 size = 32;
2500 isfloat = 1;
2501 }
2502 else
2503 {
2504 func (stream, "<illegal constant %.8x:%x:%x>",
2505 bits, cmode, op);
2506 size = 32;
2507 break;
2508 }
2509 switch (size)
2510 {
2511 case 8:
2512 func (stream, "#%ld\t; 0x%.2lx", value, value);
2513 break;
2514
2515 case 16:
2516 func (stream, "#%ld\t; 0x%.4lx", value, value);
2517 break;
2518
2519 case 32:
2520 if (isfloat)
2521 {
2522 unsigned char valbytes[4];
2523 double fvalue;
2524
2525 /* Do this a byte at a time so we don't have to
2526 worry about the host's endianness. */
2527 valbytes[0] = value & 0xff;
2528 valbytes[1] = (value >> 8) & 0xff;
2529 valbytes[2] = (value >> 16) & 0xff;
2530 valbytes[3] = (value >> 24) & 0xff;
2531
2532 floatformat_to_double
2533 (&floatformat_ieee_single_little, valbytes,
2534 &fvalue);
2535
2536 func (stream, "#%.7g\t; 0x%.8lx", fvalue,
2537 value);
2538 }
2539 else
2540 func (stream, "#%ld\t; 0x%.8lx",
2541 (long) ((value & 0x80000000)
2542 ? value | ~0xffffffffl : value), value);
2543 break;
2544
2545 case 64:
2546 func (stream, "#0x%.8lx%.8lx", hival, value);
2547 break;
2548
2549 default:
2550 abort ();
2551 }
2552 }
2553 break;
2554
2555 case 'F':
2556 {
2557 int regno = ((given >> 16) & 0xf) | ((given >> (7 - 4)) & 0x10);
2558 int num = (given >> 8) & 0x3;
2559
2560 if (!num)
2561 func (stream, "{d%d}", regno);
2562 else if (num + regno >= 32)
2563 func (stream, "{d%d-<overflow reg d%d}", regno, regno + num);
2564 else
2565 func (stream, "{d%d-d%d}", regno, regno + num);
2566 }
2567 break;
2568
2569
2570 case '0': case '1': case '2': case '3': case '4':
2571 case '5': case '6': case '7': case '8': case '9':
2572 {
2573 int width;
2574 unsigned long value;
2575
2576 c = arm_decode_bitfield (c, given, &value, &width);
2577
2578 switch (*c)
2579 {
2580 case 'r':
2581 func (stream, "%s", arm_regnames[value]);
2582 break;
2583 case 'd':
2584 func (stream, "%ld", value);
2585 break;
2586 case 'e':
2587 func (stream, "%ld", (1ul << width) - value);
2588 break;
2589
2590 case 'S':
2591 case 'T':
2592 case 'U':
2593 /* various width encodings */
2594 {
2595 int base = 8 << (*c - 'S'); /* 8,16 or 32 */
2596 int limit;
2597 unsigned low, high;
2598
2599 c++;
2600 if (*c >= '0' && *c <= '9')
2601 limit = *c - '0';
2602 else if (*c >= 'a' && *c <= 'f')
2603 limit = *c - 'a' + 10;
2604 else
2605 abort ();
2606 low = limit >> 2;
2607 high = limit & 3;
2608
2609 if (value < low || value > high)
2610 func (stream, "<illegal width %d>", base << value);
2611 else
2612 func (stream, "%d", base << value);
2613 }
2614 break;
2615 case 'R':
2616 if (given & (1 << 6))
2617 goto Q;
2618 /* FALLTHROUGH */
2619 case 'D':
2620 func (stream, "d%ld", value);
2621 break;
2622 case 'Q':
2623 Q:
2624 if (value & 1)
2625 func (stream, "<illegal reg q%ld.5>", value >> 1);
2626 else
2627 func (stream, "q%ld", value >> 1);
2628 break;
2629
2630 case '`':
2631 c++;
2632 if (value == 0)
2633 func (stream, "%c", *c);
2634 break;
2635 case '\'':
2636 c++;
2637 if (value == ((1ul << width) - 1))
2638 func (stream, "%c", *c);
2639 break;
2640 case '?':
2641 func (stream, "%c", c[(1 << width) - (int)value]);
2642 c += 1 << width;
2643 break;
2644 default:
2645 abort ();
2646 }
2647 break;
2648
2649 default:
2650 abort ();
2651 }
2652 }
2653 }
2654 else
2655 func (stream, "%c", *c);
2656 }
2657 return TRUE;
2658 }
2659 }
2660 return FALSE;
2661 }
2662
2663 /* Print one ARM instruction from PC on INFO->STREAM. */
2664
2665 static void
print_insn_arm(bfd_vma pc,struct disassemble_info * info,long given)2666 print_insn_arm (bfd_vma pc, struct disassemble_info *info, long given)
2667 {
2668 const struct opcode32 *insn;
2669 void *stream = info->stream;
2670 fprintf_ftype func = info->fprintf_func;
2671
2672 if (print_insn_coprocessor (pc, info, given, FALSE))
2673 return;
2674
2675 if (print_insn_neon (info, given, FALSE))
2676 return;
2677
2678 for (insn = arm_opcodes; insn->assembler; insn++)
2679 {
2680 if (insn->value == FIRST_IWMMXT_INSN
2681 && info->mach != bfd_mach_arm_XScale
2682 && info->mach != bfd_mach_arm_iWMMXt)
2683 insn = insn + IWMMXT_INSN_COUNT;
2684
2685 if ((given & insn->mask) == insn->value
2686 /* Special case: an instruction with all bits set in the condition field
2687 (0xFnnn_nnnn) is only matched if all those bits are set in insn->mask,
2688 or by the catchall at the end of the table. */
2689 && ((given & 0xF0000000) != 0xF0000000
2690 || (insn->mask & 0xF0000000) == 0xF0000000
2691 || (insn->mask == 0 && insn->value == 0)))
2692 {
2693 const char *c;
2694
2695 for (c = insn->assembler; *c; c++)
2696 {
2697 if (*c == '%')
2698 {
2699 switch (*++c)
2700 {
2701 case '%':
2702 func (stream, "%%");
2703 break;
2704
2705 case 'a':
2706 print_arm_address (pc, info, given);
2707 break;
2708
2709 case 'P':
2710 /* Set P address bit and use normal address
2711 printing routine. */
2712 print_arm_address (pc, info, given | (1 << 24));
2713 break;
2714
2715 case 's':
2716 if ((given & 0x004f0000) == 0x004f0000)
2717 {
2718 /* PC relative with immediate offset. */
2719 int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2720
2721 if ((given & 0x00800000) == 0)
2722 offset = -offset;
2723
2724 func (stream, "[pc, #%d]\t; ", offset);
2725 info->print_address_func (offset + pc + 8, info);
2726 }
2727 else
2728 {
2729 func (stream, "[%s",
2730 arm_regnames[(given >> 16) & 0xf]);
2731 if ((given & 0x01000000) != 0)
2732 {
2733 /* Pre-indexed. */
2734 if ((given & 0x00400000) == 0x00400000)
2735 {
2736 /* Immediate. */
2737 int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2738 if (offset)
2739 func (stream, ", #%s%d",
2740 (((given & 0x00800000) == 0)
2741 ? "-" : ""), offset);
2742 }
2743 else
2744 {
2745 /* Register. */
2746 func (stream, ", %s%s",
2747 (((given & 0x00800000) == 0)
2748 ? "-" : ""),
2749 arm_regnames[given & 0xf]);
2750 }
2751
2752 func (stream, "]%s",
2753 ((given & 0x00200000) != 0) ? "!" : "");
2754 }
2755 else
2756 {
2757 /* Post-indexed. */
2758 if ((given & 0x00400000) == 0x00400000)
2759 {
2760 /* Immediate. */
2761 int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2762 if (offset)
2763 func (stream, "], #%s%d",
2764 (((given & 0x00800000) == 0)
2765 ? "-" : ""), offset);
2766 else
2767 func (stream, "]");
2768 }
2769 else
2770 {
2771 /* Register. */
2772 func (stream, "], %s%s",
2773 (((given & 0x00800000) == 0)
2774 ? "-" : ""),
2775 arm_regnames[given & 0xf]);
2776 }
2777 }
2778 }
2779 break;
2780
2781 case 'b':
2782 {
2783 int disp = (((given & 0xffffff) ^ 0x800000) - 0x800000);
2784 info->print_address_func (disp*4 + pc + 8, info);
2785 }
2786 break;
2787
2788 case 'c':
2789 if (((given >> 28) & 0xf) != 0xe)
2790 func (stream, "%s",
2791 arm_conditional [(given >> 28) & 0xf]);
2792 break;
2793
2794 case 'm':
2795 {
2796 int started = 0;
2797 int reg;
2798
2799 func (stream, "{");
2800 for (reg = 0; reg < 16; reg++)
2801 if ((given & (1 << reg)) != 0)
2802 {
2803 if (started)
2804 func (stream, ", ");
2805 started = 1;
2806 func (stream, "%s", arm_regnames[reg]);
2807 }
2808 func (stream, "}");
2809 }
2810 break;
2811
2812 case 'q':
2813 arm_decode_shift (given, func, stream, 0);
2814 break;
2815
2816 case 'o':
2817 if ((given & 0x02000000) != 0)
2818 {
2819 int rotate = (given & 0xf00) >> 7;
2820 int immed = (given & 0xff);
2821 immed = (((immed << (32 - rotate))
2822 | (immed >> rotate)) & 0xffffffff);
2823 func (stream, "#%d\t; 0x%x", immed, immed);
2824 }
2825 else
2826 arm_decode_shift (given, func, stream, 1);
2827 break;
2828
2829 case 'p':
2830 if ((given & 0x0000f000) == 0x0000f000)
2831 func (stream, "p");
2832 break;
2833
2834 case 't':
2835 if ((given & 0x01200000) == 0x00200000)
2836 func (stream, "t");
2837 break;
2838
2839 case 'A':
2840 func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
2841
2842 if ((given & (1 << 24)) != 0)
2843 {
2844 int offset = given & 0xff;
2845
2846 if (offset)
2847 func (stream, ", #%s%d]%s",
2848 ((given & 0x00800000) == 0 ? "-" : ""),
2849 offset * 4,
2850 ((given & 0x00200000) != 0 ? "!" : ""));
2851 else
2852 func (stream, "]");
2853 }
2854 else
2855 {
2856 int offset = given & 0xff;
2857
2858 func (stream, "]");
2859
2860 if (given & (1 << 21))
2861 {
2862 if (offset)
2863 func (stream, ", #%s%d",
2864 ((given & 0x00800000) == 0 ? "-" : ""),
2865 offset * 4);
2866 }
2867 else
2868 func (stream, ", {%d}", offset);
2869 }
2870 break;
2871
2872 case 'B':
2873 /* Print ARM V5 BLX(1) address: pc+25 bits. */
2874 {
2875 bfd_vma address;
2876 bfd_vma offset = 0;
2877
2878 if (given & 0x00800000)
2879 /* Is signed, hi bits should be ones. */
2880 offset = (-1) ^ 0x00ffffff;
2881
2882 /* Offset is (SignExtend(offset field)<<2). */
2883 offset += given & 0x00ffffff;
2884 offset <<= 2;
2885 address = offset + pc + 8;
2886
2887 if (given & 0x01000000)
2888 /* H bit allows addressing to 2-byte boundaries. */
2889 address += 2;
2890
2891 info->print_address_func (address, info);
2892 }
2893 break;
2894
2895 case 'C':
2896 func (stream, "_");
2897 if (given & 0x80000)
2898 func (stream, "f");
2899 if (given & 0x40000)
2900 func (stream, "s");
2901 if (given & 0x20000)
2902 func (stream, "x");
2903 if (given & 0x10000)
2904 func (stream, "c");
2905 break;
2906
2907 case 'U':
2908 switch (given & 0xf)
2909 {
2910 case 0xf: func(stream, "sy"); break;
2911 case 0x7: func(stream, "un"); break;
2912 case 0xe: func(stream, "st"); break;
2913 case 0x6: func(stream, "unst"); break;
2914 default:
2915 func(stream, "#%d", (int)given & 0xf);
2916 break;
2917 }
2918 break;
2919
2920 case '0': case '1': case '2': case '3': case '4':
2921 case '5': case '6': case '7': case '8': case '9':
2922 {
2923 int width;
2924 unsigned long value;
2925
2926 c = arm_decode_bitfield (c, given, &value, &width);
2927
2928 switch (*c)
2929 {
2930 case 'r':
2931 func (stream, "%s", arm_regnames[value]);
2932 break;
2933 case 'd':
2934 func (stream, "%ld", value);
2935 break;
2936 case 'b':
2937 func (stream, "%ld", value * 8);
2938 break;
2939 case 'W':
2940 func (stream, "%ld", value + 1);
2941 break;
2942 case 'x':
2943 func (stream, "0x%08lx", value);
2944
2945 /* Some SWI instructions have special
2946 meanings. */
2947 if ((given & 0x0fffffff) == 0x0FF00000)
2948 func (stream, "\t; IMB");
2949 else if ((given & 0x0fffffff) == 0x0FF00001)
2950 func (stream, "\t; IMBRange");
2951 break;
2952 case 'X':
2953 func (stream, "%01lx", value & 0xf);
2954 break;
2955 case '`':
2956 c++;
2957 if (value == 0)
2958 func (stream, "%c", *c);
2959 break;
2960 case '\'':
2961 c++;
2962 if (value == ((1ul << width) - 1))
2963 func (stream, "%c", *c);
2964 break;
2965 case '?':
2966 func (stream, "%c", c[(1 << width) - (int)value]);
2967 c += 1 << width;
2968 break;
2969 default:
2970 abort ();
2971 }
2972 break;
2973
2974 case 'e':
2975 {
2976 int imm;
2977
2978 imm = (given & 0xf) | ((given & 0xfff00) >> 4);
2979 func (stream, "%d", imm);
2980 }
2981 break;
2982
2983 case 'E':
2984 /* LSB and WIDTH fields of BFI or BFC. The machine-
2985 language instruction encodes LSB and MSB. */
2986 {
2987 long msb = (given & 0x001f0000) >> 16;
2988 long lsb = (given & 0x00000f80) >> 7;
2989
2990 long width = msb - lsb + 1;
2991 if (width > 0)
2992 func (stream, "#%lu, #%lu", lsb, width);
2993 else
2994 func (stream, "(invalid: %lu:%lu)", lsb, msb);
2995 }
2996 break;
2997
2998 case 'V':
2999 /* 16-bit unsigned immediate from a MOVT or MOVW
3000 instruction, encoded in bits 0:11 and 15:19. */
3001 {
3002 long hi = (given & 0x000f0000) >> 4;
3003 long lo = (given & 0x00000fff);
3004 long imm16 = hi | lo;
3005 func (stream, "#%lu\t; 0x%lx", imm16, imm16);
3006 }
3007 break;
3008
3009 default:
3010 abort ();
3011 }
3012 }
3013 }
3014 else
3015 func (stream, "%c", *c);
3016 }
3017 return;
3018 }
3019 }
3020 abort ();
3021 }
3022
3023 /* Print one 16-bit Thumb instruction from PC on INFO->STREAM. */
3024
3025 static void
print_insn_thumb16(bfd_vma pc,struct disassemble_info * info,long given)3026 print_insn_thumb16 (bfd_vma pc, struct disassemble_info *info, long given)
3027 {
3028 const struct opcode16 *insn;
3029 void *stream = info->stream;
3030 fprintf_ftype func = info->fprintf_func;
3031
3032 for (insn = thumb_opcodes; insn->assembler; insn++)
3033 if ((given & insn->mask) == insn->value)
3034 {
3035 const char *c = insn->assembler;
3036 for (; *c; c++)
3037 {
3038 int domaskpc = 0;
3039 int domasklr = 0;
3040
3041 if (*c != '%')
3042 {
3043 func (stream, "%c", *c);
3044 continue;
3045 }
3046
3047 switch (*++c)
3048 {
3049 case '%':
3050 func (stream, "%%");
3051 break;
3052
3053 case 'c':
3054 if (ifthen_state)
3055 func (stream, "%s", arm_conditional[IFTHEN_COND]);
3056 break;
3057
3058 case 'C':
3059 if (ifthen_state)
3060 func (stream, "%s", arm_conditional[IFTHEN_COND]);
3061 else
3062 func (stream, "s");
3063 break;
3064
3065 case 'I':
3066 {
3067 unsigned int tmp;
3068
3069 ifthen_next_state = given & 0xff;
3070 for (tmp = given << 1; tmp & 0xf; tmp <<= 1)
3071 func (stream, ((given ^ tmp) & 0x10) ? "e" : "t");
3072 func (stream, "\t%s", arm_conditional[(given >> 4) & 0xf]);
3073 }
3074 break;
3075
3076 case 'x':
3077 if (ifthen_next_state)
3078 func (stream, "\t; unpredictable branch in IT block\n");
3079 break;
3080
3081 case 'X':
3082 if (ifthen_state)
3083 func (stream, "\t; unpredictable <IT:%s>",
3084 arm_conditional[IFTHEN_COND]);
3085 break;
3086
3087 case 'S':
3088 {
3089 long reg;
3090
3091 reg = (given >> 3) & 0x7;
3092 if (given & (1 << 6))
3093 reg += 8;
3094
3095 func (stream, "%s", arm_regnames[reg]);
3096 }
3097 break;
3098
3099 case 'D':
3100 {
3101 long reg;
3102
3103 reg = given & 0x7;
3104 if (given & (1 << 7))
3105 reg += 8;
3106
3107 func (stream, "%s", arm_regnames[reg]);
3108 }
3109 break;
3110
3111 case 'N':
3112 if (given & (1 << 8))
3113 domasklr = 1;
3114 /* Fall through. */
3115 case 'O':
3116 if (*c == 'O' && (given & (1 << 8)))
3117 domaskpc = 1;
3118 /* Fall through. */
3119 case 'M':
3120 {
3121 int started = 0;
3122 int reg;
3123
3124 func (stream, "{");
3125
3126 /* It would be nice if we could spot
3127 ranges, and generate the rS-rE format: */
3128 for (reg = 0; (reg < 8); reg++)
3129 if ((given & (1 << reg)) != 0)
3130 {
3131 if (started)
3132 func (stream, ", ");
3133 started = 1;
3134 func (stream, "%s", arm_regnames[reg]);
3135 }
3136
3137 if (domasklr)
3138 {
3139 if (started)
3140 func (stream, ", ");
3141 started = 1;
3142 func (stream, arm_regnames[14] /* "lr" */);
3143 }
3144
3145 if (domaskpc)
3146 {
3147 if (started)
3148 func (stream, ", ");
3149 func (stream, arm_regnames[15] /* "pc" */);
3150 }
3151
3152 func (stream, "}");
3153 }
3154 break;
3155
3156 case 'b':
3157 /* Print ARM V6T2 CZB address: pc+4+6 bits. */
3158 {
3159 bfd_vma address = (pc + 4
3160 + ((given & 0x00f8) >> 2)
3161 + ((given & 0x0200) >> 3));
3162 info->print_address_func (address, info);
3163 }
3164 break;
3165
3166 case 's':
3167 /* Right shift immediate -- bits 6..10; 1-31 print
3168 as themselves, 0 prints as 32. */
3169 {
3170 long imm = (given & 0x07c0) >> 6;
3171 if (imm == 0)
3172 imm = 32;
3173 func (stream, "#%ld", imm);
3174 }
3175 break;
3176
3177 case '0': case '1': case '2': case '3': case '4':
3178 case '5': case '6': case '7': case '8': case '9':
3179 {
3180 int bitstart = *c++ - '0';
3181 int bitend = 0;
3182
3183 while (*c >= '0' && *c <= '9')
3184 bitstart = (bitstart * 10) + *c++ - '0';
3185
3186 switch (*c)
3187 {
3188 case '-':
3189 {
3190 long reg;
3191
3192 c++;
3193 while (*c >= '0' && *c <= '9')
3194 bitend = (bitend * 10) + *c++ - '0';
3195 if (!bitend)
3196 abort ();
3197 reg = given >> bitstart;
3198 reg &= (2 << (bitend - bitstart)) - 1;
3199 switch (*c)
3200 {
3201 case 'r':
3202 func (stream, "%s", arm_regnames[reg]);
3203 break;
3204
3205 case 'd':
3206 func (stream, "%ld", reg);
3207 break;
3208
3209 case 'H':
3210 func (stream, "%ld", reg << 1);
3211 break;
3212
3213 case 'W':
3214 func (stream, "%ld", reg << 2);
3215 break;
3216
3217 case 'a':
3218 /* PC-relative address -- the bottom two
3219 bits of the address are dropped
3220 before the calculation. */
3221 info->print_address_func
3222 (((pc + 4) & ~3) + (reg << 2), info);
3223 break;
3224
3225 case 'x':
3226 func (stream, "0x%04lx", reg);
3227 break;
3228
3229 case 'B':
3230 reg = ((reg ^ (1 << bitend)) - (1 << bitend));
3231 info->print_address_func (reg * 2 + pc + 4, info);
3232 break;
3233
3234 case 'c':
3235 func (stream, "%s", arm_conditional [reg]);
3236 break;
3237
3238 default:
3239 abort ();
3240 }
3241 }
3242 break;
3243
3244 case '\'':
3245 c++;
3246 if ((given & (1 << bitstart)) != 0)
3247 func (stream, "%c", *c);
3248 break;
3249
3250 case '?':
3251 ++c;
3252 if ((given & (1 << bitstart)) != 0)
3253 func (stream, "%c", *c++);
3254 else
3255 func (stream, "%c", *++c);
3256 break;
3257
3258 default:
3259 abort ();
3260 }
3261 }
3262 break;
3263
3264 default:
3265 abort ();
3266 }
3267 }
3268 return;
3269 }
3270
3271 /* No match. */
3272 abort ();
3273 }
3274
3275 /* Return the name of an V7M special register. */
3276 static const char *
psr_name(int regno)3277 psr_name (int regno)
3278 {
3279 switch (regno)
3280 {
3281 case 0: return "APSR";
3282 case 1: return "IAPSR";
3283 case 2: return "EAPSR";
3284 case 3: return "PSR";
3285 case 5: return "IPSR";
3286 case 6: return "EPSR";
3287 case 7: return "IEPSR";
3288 case 8: return "MSP";
3289 case 9: return "PSP";
3290 case 16: return "PRIMASK";
3291 case 17: return "BASEPRI";
3292 case 18: return "BASEPRI_MASK";
3293 case 19: return "FAULTMASK";
3294 case 20: return "CONTROL";
3295 default: return "<unknown>";
3296 }
3297 }
3298
3299 /* Print one 32-bit Thumb instruction from PC on INFO->STREAM. */
3300
3301 static void
print_insn_thumb32(bfd_vma pc,struct disassemble_info * info,long given)3302 print_insn_thumb32 (bfd_vma pc, struct disassemble_info *info, long given)
3303 {
3304 const struct opcode32 *insn;
3305 void *stream = info->stream;
3306 fprintf_ftype func = info->fprintf_func;
3307
3308 if (print_insn_coprocessor (pc, info, given, TRUE))
3309 return;
3310
3311 if (print_insn_neon (info, given, TRUE))
3312 return;
3313
3314 for (insn = thumb32_opcodes; insn->assembler; insn++)
3315 if ((given & insn->mask) == insn->value)
3316 {
3317 const char *c = insn->assembler;
3318 for (; *c; c++)
3319 {
3320 if (*c != '%')
3321 {
3322 func (stream, "%c", *c);
3323 continue;
3324 }
3325
3326 switch (*++c)
3327 {
3328 case '%':
3329 func (stream, "%%");
3330 break;
3331
3332 case 'c':
3333 if (ifthen_state)
3334 func (stream, "%s", arm_conditional[IFTHEN_COND]);
3335 break;
3336
3337 case 'x':
3338 if (ifthen_next_state)
3339 func (stream, "\t; unpredictable branch in IT block\n");
3340 break;
3341
3342 case 'X':
3343 if (ifthen_state)
3344 func (stream, "\t; unpredictable <IT:%s>",
3345 arm_conditional[IFTHEN_COND]);
3346 break;
3347
3348 case 'I':
3349 {
3350 unsigned int imm12 = 0;
3351 imm12 |= (given & 0x000000ffu);
3352 imm12 |= (given & 0x00007000u) >> 4;
3353 imm12 |= (given & 0x04000000u) >> 15;
3354 func (stream, "#%u\t; 0x%x", imm12, imm12);
3355 }
3356 break;
3357
3358 case 'M':
3359 {
3360 unsigned int bits = 0, imm, imm8, mod;
3361 bits |= (given & 0x000000ffu);
3362 bits |= (given & 0x00007000u) >> 4;
3363 bits |= (given & 0x04000000u) >> 15;
3364 imm8 = (bits & 0x0ff);
3365 mod = (bits & 0xf00) >> 8;
3366 switch (mod)
3367 {
3368 case 0: imm = imm8; break;
3369 case 1: imm = ((imm8<<16) | imm8); break;
3370 case 2: imm = ((imm8<<24) | (imm8 << 8)); break;
3371 case 3: imm = ((imm8<<24) | (imm8 << 16) | (imm8 << 8) | imm8); break;
3372 default:
3373 mod = (bits & 0xf80) >> 7;
3374 imm8 = (bits & 0x07f) | 0x80;
3375 imm = (((imm8 << (32 - mod)) | (imm8 >> mod)) & 0xffffffff);
3376 }
3377 func (stream, "#%u\t; 0x%x", imm, imm);
3378 }
3379 break;
3380
3381 case 'J':
3382 {
3383 unsigned int imm = 0;
3384 imm |= (given & 0x000000ffu);
3385 imm |= (given & 0x00007000u) >> 4;
3386 imm |= (given & 0x04000000u) >> 15;
3387 imm |= (given & 0x000f0000u) >> 4;
3388 func (stream, "#%u\t; 0x%x", imm, imm);
3389 }
3390 break;
3391
3392 case 'K':
3393 {
3394 unsigned int imm = 0;
3395 imm |= (given & 0x000f0000u) >> 16;
3396 imm |= (given & 0x00000ff0u) >> 0;
3397 imm |= (given & 0x0000000fu) << 12;
3398 func (stream, "#%u\t; 0x%x", imm, imm);
3399 }
3400 break;
3401
3402 case 'S':
3403 {
3404 unsigned int reg = (given & 0x0000000fu);
3405 unsigned int stp = (given & 0x00000030u) >> 4;
3406 unsigned int imm = 0;
3407 imm |= (given & 0x000000c0u) >> 6;
3408 imm |= (given & 0x00007000u) >> 10;
3409
3410 func (stream, "%s", arm_regnames[reg]);
3411 switch (stp)
3412 {
3413 case 0:
3414 if (imm > 0)
3415 func (stream, ", lsl #%u", imm);
3416 break;
3417
3418 case 1:
3419 if (imm == 0)
3420 imm = 32;
3421 func (stream, ", lsr #%u", imm);
3422 break;
3423
3424 case 2:
3425 if (imm == 0)
3426 imm = 32;
3427 func (stream, ", asr #%u", imm);
3428 break;
3429
3430 case 3:
3431 if (imm == 0)
3432 func (stream, ", rrx");
3433 else
3434 func (stream, ", ror #%u", imm);
3435 }
3436 }
3437 break;
3438
3439 case 'a':
3440 {
3441 unsigned int Rn = (given & 0x000f0000) >> 16;
3442 unsigned int U = (given & 0x00800000) >> 23;
3443 unsigned int op = (given & 0x00000f00) >> 8;
3444 unsigned int i12 = (given & 0x00000fff);
3445 unsigned int i8 = (given & 0x000000ff);
3446 bfd_boolean writeback = FALSE, postind = FALSE;
3447 int offset = 0;
3448
3449 func (stream, "[%s", arm_regnames[Rn]);
3450 if (U) /* 12-bit positive immediate offset */
3451 offset = i12;
3452 else if (Rn == 15) /* 12-bit negative immediate offset */
3453 offset = -(int)i12;
3454 else if (op == 0x0) /* shifted register offset */
3455 {
3456 unsigned int Rm = (i8 & 0x0f);
3457 unsigned int sh = (i8 & 0x30) >> 4;
3458 func (stream, ", %s", arm_regnames[Rm]);
3459 if (sh)
3460 func (stream, ", lsl #%u", sh);
3461 func (stream, "]");
3462 break;
3463 }
3464 else switch (op)
3465 {
3466 case 0xE: /* 8-bit positive immediate offset */
3467 offset = i8;
3468 break;
3469
3470 case 0xC: /* 8-bit negative immediate offset */
3471 offset = -i8;
3472 break;
3473
3474 case 0xF: /* 8-bit + preindex with wb */
3475 offset = i8;
3476 writeback = TRUE;
3477 break;
3478
3479 case 0xD: /* 8-bit - preindex with wb */
3480 offset = -i8;
3481 writeback = TRUE;
3482 break;
3483
3484 case 0xB: /* 8-bit + postindex */
3485 offset = i8;
3486 postind = TRUE;
3487 break;
3488
3489 case 0x9: /* 8-bit - postindex */
3490 offset = -i8;
3491 postind = TRUE;
3492 break;
3493
3494 default:
3495 func (stream, ", <undefined>]");
3496 goto skip;
3497 }
3498
3499 if (postind)
3500 func (stream, "], #%d", offset);
3501 else
3502 {
3503 if (offset)
3504 func (stream, ", #%d", offset);
3505 func (stream, writeback ? "]!" : "]");
3506 }
3507
3508 if (Rn == 15)
3509 {
3510 func (stream, "\t; ");
3511 info->print_address_func (((pc + 4) & ~3) + offset, info);
3512 }
3513 }
3514 skip:
3515 break;
3516
3517 case 'A':
3518 {
3519 unsigned int P = (given & 0x01000000) >> 24;
3520 unsigned int U = (given & 0x00800000) >> 23;
3521 unsigned int W = (given & 0x00400000) >> 21;
3522 unsigned int Rn = (given & 0x000f0000) >> 16;
3523 unsigned int off = (given & 0x000000ff);
3524
3525 func (stream, "[%s", arm_regnames[Rn]);
3526 if (P)
3527 {
3528 if (off || !U)
3529 func (stream, ", #%c%u", U ? '+' : '-', off * 4);
3530 func (stream, "]");
3531 if (W)
3532 func (stream, "!");
3533 }
3534 else
3535 {
3536 func (stream, "], ");
3537 if (W)
3538 func (stream, "#%c%u", U ? '+' : '-', off * 4);
3539 else
3540 func (stream, "{%u}", off);
3541 }
3542 }
3543 break;
3544
3545 case 'w':
3546 {
3547 unsigned int Sbit = (given & 0x01000000) >> 24;
3548 unsigned int type = (given & 0x00600000) >> 21;
3549 switch (type)
3550 {
3551 case 0: func (stream, Sbit ? "sb" : "b"); break;
3552 case 1: func (stream, Sbit ? "sh" : "h"); break;
3553 case 2:
3554 if (Sbit)
3555 func (stream, "??");
3556 break;
3557 case 3:
3558 func (stream, "??");
3559 break;
3560 }
3561 }
3562 break;
3563
3564 case 'm':
3565 {
3566 int started = 0;
3567 int reg;
3568
3569 func (stream, "{");
3570 for (reg = 0; reg < 16; reg++)
3571 if ((given & (1 << reg)) != 0)
3572 {
3573 if (started)
3574 func (stream, ", ");
3575 started = 1;
3576 func (stream, "%s", arm_regnames[reg]);
3577 }
3578 func (stream, "}");
3579 }
3580 break;
3581
3582 case 'E':
3583 {
3584 unsigned int msb = (given & 0x0000001f);
3585 unsigned int lsb = 0;
3586 lsb |= (given & 0x000000c0u) >> 6;
3587 lsb |= (given & 0x00007000u) >> 10;
3588 func (stream, "#%u, #%u", lsb, msb - lsb + 1);
3589 }
3590 break;
3591
3592 case 'F':
3593 {
3594 unsigned int width = (given & 0x0000001f) + 1;
3595 unsigned int lsb = 0;
3596 lsb |= (given & 0x000000c0u) >> 6;
3597 lsb |= (given & 0x00007000u) >> 10;
3598 func (stream, "#%u, #%u", lsb, width);
3599 }
3600 break;
3601
3602 case 'b':
3603 {
3604 unsigned int S = (given & 0x04000000u) >> 26;
3605 unsigned int J1 = (given & 0x00002000u) >> 13;
3606 unsigned int J2 = (given & 0x00000800u) >> 11;
3607 int offset = 0;
3608
3609 offset |= !S << 20;
3610 offset |= J2 << 19;
3611 offset |= J1 << 18;
3612 offset |= (given & 0x003f0000) >> 4;
3613 offset |= (given & 0x000007ff) << 1;
3614 offset -= (1 << 20);
3615
3616 info->print_address_func (pc + 4 + offset, info);
3617 }
3618 break;
3619
3620 case 'B':
3621 {
3622 unsigned int S = (given & 0x04000000u) >> 26;
3623 unsigned int I1 = (given & 0x00002000u) >> 13;
3624 unsigned int I2 = (given & 0x00000800u) >> 11;
3625 int offset = 0;
3626
3627 offset |= !S << 24;
3628 offset |= !(I1 ^ S) << 23;
3629 offset |= !(I2 ^ S) << 22;
3630 offset |= (given & 0x03ff0000u) >> 4;
3631 offset |= (given & 0x000007ffu) << 1;
3632 offset -= (1 << 24);
3633 offset += pc + 4;
3634
3635 /* BLX target addresses are always word aligned. */
3636 if ((given & 0x00001000u) == 0)
3637 offset &= ~2u;
3638
3639 info->print_address_func (offset, info);
3640 }
3641 break;
3642
3643 case 's':
3644 {
3645 unsigned int shift = 0;
3646 shift |= (given & 0x000000c0u) >> 6;
3647 shift |= (given & 0x00007000u) >> 10;
3648 if (given & 0x00200000u)
3649 func (stream, ", asr #%u", shift);
3650 else if (shift)
3651 func (stream, ", lsl #%u", shift);
3652 /* else print nothing - lsl #0 */
3653 }
3654 break;
3655
3656 case 'R':
3657 {
3658 unsigned int rot = (given & 0x00000030) >> 4;
3659 if (rot)
3660 func (stream, ", ror #%u", rot * 8);
3661 }
3662 break;
3663
3664 case 'U':
3665 switch (given & 0xf)
3666 {
3667 case 0xf: func(stream, "sy"); break;
3668 case 0x7: func(stream, "un"); break;
3669 case 0xe: func(stream, "st"); break;
3670 case 0x6: func(stream, "unst"); break;
3671 default:
3672 func(stream, "#%d", (int)given & 0xf);
3673 break;
3674 }
3675 break;
3676
3677 case 'C':
3678 if ((given & 0xff) == 0)
3679 {
3680 func (stream, "%cPSR_", (given & 0x100000) ? 'S' : 'C');
3681 if (given & 0x800)
3682 func (stream, "f");
3683 if (given & 0x400)
3684 func (stream, "s");
3685 if (given & 0x200)
3686 func (stream, "x");
3687 if (given & 0x100)
3688 func (stream, "c");
3689 }
3690 else
3691 {
3692 func (stream, psr_name (given & 0xff));
3693 }
3694 break;
3695
3696 case 'D':
3697 if ((given & 0xff) == 0)
3698 func (stream, "%cPSR", (given & 0x100000) ? 'S' : 'C');
3699 else
3700 func (stream, psr_name (given & 0xff));
3701 break;
3702
3703 case '0': case '1': case '2': case '3': case '4':
3704 case '5': case '6': case '7': case '8': case '9':
3705 {
3706 int width;
3707 unsigned long val;
3708
3709 c = arm_decode_bitfield (c, given, &val, &width);
3710
3711 switch (*c)
3712 {
3713 case 'd': func (stream, "%lu", val); break;
3714 case 'W': func (stream, "%lu", val * 4); break;
3715 case 'r': func (stream, "%s", arm_regnames[val]); break;
3716
3717 case 'c':
3718 func (stream, "%s", arm_conditional[val]);
3719 break;
3720
3721 case '\'':
3722 c++;
3723 if (val == ((1ul << width) - 1))
3724 func (stream, "%c", *c);
3725 break;
3726
3727 case '`':
3728 c++;
3729 if (val == 0)
3730 func (stream, "%c", *c);
3731 break;
3732
3733 case '?':
3734 func (stream, "%c", c[(1 << width) - (int)val]);
3735 c += 1 << width;
3736 break;
3737
3738 default:
3739 abort ();
3740 }
3741 }
3742 break;
3743
3744 default:
3745 abort ();
3746 }
3747 }
3748 return;
3749 }
3750
3751 /* No match. */
3752 abort ();
3753 }
3754
3755 /* Print data bytes on INFO->STREAM. */
3756
3757 static void
print_insn_data(bfd_vma pc ATTRIBUTE_UNUSED,struct disassemble_info * info,long given)3758 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED, struct disassemble_info *info,
3759 long given)
3760 {
3761 switch (info->bytes_per_chunk)
3762 {
3763 case 1:
3764 info->fprintf_func (info->stream, ".byte\t0x%02lx", given);
3765 break;
3766 case 2:
3767 info->fprintf_func (info->stream, ".short\t0x%04lx", given);
3768 break;
3769 case 4:
3770 info->fprintf_func (info->stream, ".word\t0x%08lx", given);
3771 break;
3772 default:
3773 abort ();
3774 }
3775 }
3776
3777 /* Disallow mapping symbols ($a, $b, $d, $t etc) from
3778 being displayed in symbol relative addresses. */
3779
3780 bfd_boolean
arm_symbol_is_valid(asymbol * sym,struct disassemble_info * info ATTRIBUTE_UNUSED)3781 arm_symbol_is_valid (asymbol * sym,
3782 struct disassemble_info * info ATTRIBUTE_UNUSED)
3783 {
3784 const char * name;
3785
3786 if (sym == NULL)
3787 return FALSE;
3788
3789 name = bfd_asymbol_name (sym);
3790
3791 return (name && *name != '$');
3792 }
3793
3794 /* Parse an individual disassembler option. */
3795
3796 void
parse_arm_disassembler_option(char * option)3797 parse_arm_disassembler_option (char *option)
3798 {
3799 if (option == NULL)
3800 return;
3801
3802 if (CONST_STRNEQ (option, "reg-names-"))
3803 {
3804 int i;
3805
3806 option += 10;
3807
3808 for (i = NUM_ARM_REGNAMES; i--;)
3809 if (strneq (option, regnames[i].name, strlen (regnames[i].name)))
3810 {
3811 regname_selected = i;
3812 break;
3813 }
3814
3815 if (i < 0)
3816 /* XXX - should break 'option' at following delimiter. */
3817 fprintf (stderr, _("Unrecognised register name set: %s\n"), option);
3818 }
3819 else if (CONST_STRNEQ (option, "force-thumb"))
3820 force_thumb = 1;
3821 else if (CONST_STRNEQ (option, "no-force-thumb"))
3822 force_thumb = 0;
3823 else
3824 /* XXX - should break 'option' at following delimiter. */
3825 fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
3826
3827 return;
3828 }
3829
3830 /* Parse the string of disassembler options, spliting it at whitespaces
3831 or commas. (Whitespace separators supported for backwards compatibility). */
3832
3833 static void
parse_disassembler_options(char * options)3834 parse_disassembler_options (char *options)
3835 {
3836 if (options == NULL)
3837 return;
3838
3839 while (*options)
3840 {
3841 parse_arm_disassembler_option (options);
3842
3843 /* Skip forward to next seperator. */
3844 while ((*options) && (! ISSPACE (*options)) && (*options != ','))
3845 ++ options;
3846 /* Skip forward past seperators. */
3847 while (ISSPACE (*options) || (*options == ','))
3848 ++ options;
3849 }
3850 }
3851
3852 /* Search back through the insn stream to determine if this instruction is
3853 conditionally executed. */
3854 static void
find_ifthen_state(bfd_vma pc,struct disassemble_info * info,bfd_boolean little)3855 find_ifthen_state (bfd_vma pc, struct disassemble_info *info,
3856 bfd_boolean little)
3857 {
3858 unsigned char b[2];
3859 unsigned int insn;
3860 int status;
3861 /* COUNT is twice the number of instructions seen. It will be odd if we
3862 just crossed an instruction boundary. */
3863 int count;
3864 int it_count;
3865 unsigned int seen_it;
3866 bfd_vma addr;
3867
3868 ifthen_address = pc;
3869 ifthen_state = 0;
3870
3871 addr = pc;
3872 count = 1;
3873 it_count = 0;
3874 seen_it = 0;
3875 /* Scan backwards looking for IT instructions, keeping track of where
3876 instruction boundaries are. We don't know if something is actually an
3877 IT instruction until we find a definite instruction boundary. */
3878 for (;;)
3879 {
3880 if (addr == 0 || info->symbol_at_address_func(addr, info))
3881 {
3882 /* A symbol must be on an instruction boundary, and will not
3883 be within an IT block. */
3884 if (seen_it && (count & 1))
3885 break;
3886
3887 return;
3888 }
3889 addr -= 2;
3890 status = info->read_memory_func (addr, (bfd_byte *)b, 2, info);
3891 if (status)
3892 return;
3893
3894 if (little)
3895 insn = (b[0]) | (b[1] << 8);
3896 else
3897 insn = (b[1]) | (b[0] << 8);
3898 if (seen_it)
3899 {
3900 if ((insn & 0xf800) < 0xe800)
3901 {
3902 /* Addr + 2 is an instruction boundary. See if this matches
3903 the expected boundary based on the position of the last
3904 IT candidate. */
3905 if (count & 1)
3906 break;
3907 seen_it = 0;
3908 }
3909 }
3910 if ((insn & 0xff00) == 0xbf00 && (insn & 0xf) != 0)
3911 {
3912 /* This could be an IT instruction. */
3913 seen_it = insn;
3914 it_count = count >> 1;
3915 }
3916 if ((insn & 0xf800) >= 0xe800)
3917 count++;
3918 else
3919 count = (count + 2) | 1;
3920 /* IT blocks contain at most 4 instructions. */
3921 if (count >= 8 && !seen_it)
3922 return;
3923 }
3924 /* We found an IT instruction. */
3925 ifthen_state = (seen_it & 0xe0) | ((seen_it << it_count) & 0x1f);
3926 if ((ifthen_state & 0xf) == 0)
3927 ifthen_state = 0;
3928 }
3929
3930 /* Try to infer the code type (Arm or Thumb) from a symbol.
3931 Returns nonzero if *MAP_TYPE was set. */
3932
3933 static int
get_sym_code_type(struct disassemble_info * info,int n,enum map_type * map_type)3934 get_sym_code_type (struct disassemble_info *info, int n,
3935 enum map_type *map_type)
3936 {
3937 elf_symbol_type *es;
3938 unsigned int type;
3939 const char *name;
3940
3941 es = *(elf_symbol_type **)(info->symtab + n);
3942 type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
3943
3944 /* If the symbol has function type then use that. */
3945 if (type == STT_FUNC || type == STT_ARM_TFUNC)
3946 {
3947 *map_type = (type == STT_ARM_TFUNC) ? MAP_THUMB : MAP_ARM;
3948 return TRUE;
3949 }
3950
3951 /* Check for mapping symbols. */
3952 name = bfd_asymbol_name(info->symtab[n]);
3953 if (name[0] == '$' && (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
3954 && (name[2] == 0 || name[2] == '.'))
3955 {
3956 *map_type = ((name[1] == 'a') ? MAP_ARM
3957 : (name[1] == 't') ? MAP_THUMB
3958 : MAP_DATA);
3959 return TRUE;
3960 }
3961
3962 return FALSE;
3963 }
3964
3965 /* NOTE: There are no checks in these routines that
3966 the relevant number of data bytes exist. */
3967
3968 static int
print_insn(bfd_vma pc,struct disassemble_info * info,bfd_boolean little)3969 print_insn (bfd_vma pc, struct disassemble_info *info, bfd_boolean little)
3970 {
3971 unsigned char b[4];
3972 long given;
3973 int status;
3974 int is_thumb = FALSE;
3975 int is_data = FALSE;
3976 unsigned int size = 4;
3977 void (*printer) (bfd_vma, struct disassemble_info *, long);
3978 bfd_boolean found = FALSE;
3979
3980 if (info->disassembler_options)
3981 {
3982 parse_disassembler_options (info->disassembler_options);
3983
3984 /* To avoid repeated parsing of these options, we remove them here. */
3985 info->disassembler_options = NULL;
3986 }
3987
3988 /* First check the full symtab for a mapping symbol, even if there
3989 are no usable non-mapping symbols for this address. */
3990 if (info->symtab != NULL
3991 && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
3992 {
3993 bfd_vma addr;
3994 int n;
3995 int last_sym = -1;
3996 enum map_type type = MAP_ARM;
3997
3998 if (pc <= last_mapping_addr)
3999 last_mapping_sym = -1;
4000 is_thumb = (last_type == MAP_THUMB);
4001 found = FALSE;
4002 /* Start scanning at the start of the function, or wherever
4003 we finished last time. */
4004 n = info->symtab_pos + 1;
4005 if (n < last_mapping_sym)
4006 n = last_mapping_sym;
4007
4008 /* Scan up to the location being disassembled. */
4009 for (; n < info->symtab_size; n++)
4010 {
4011 addr = bfd_asymbol_value (info->symtab[n]);
4012 if (addr > pc)
4013 break;
4014 if ((info->section == NULL
4015 || info->section == info->symtab[n]->section)
4016 && get_sym_code_type (info, n, &type))
4017 {
4018 last_sym = n;
4019 found = TRUE;
4020 }
4021 }
4022
4023 if (!found)
4024 {
4025 n = info->symtab_pos;
4026 if (n < last_mapping_sym - 1)
4027 n = last_mapping_sym - 1;
4028
4029 /* No mapping symbol found at this address. Look backwards
4030 for a preceeding one. */
4031 for (; n >= 0; n--)
4032 {
4033 if (get_sym_code_type (info, n, &type))
4034 {
4035 last_sym = n;
4036 found = TRUE;
4037 break;
4038 }
4039 }
4040 }
4041
4042 last_mapping_sym = last_sym;
4043 last_type = type;
4044 is_thumb = (last_type == MAP_THUMB);
4045 is_data = (last_type == MAP_DATA);
4046
4047 /* Look a little bit ahead to see if we should print out
4048 two or four bytes of data. If there's a symbol,
4049 mapping or otherwise, after two bytes then don't
4050 print more. */
4051 if (is_data)
4052 {
4053 size = 4 - (pc & 3);
4054 for (n = last_sym + 1; n < info->symtab_size; n++)
4055 {
4056 addr = bfd_asymbol_value (info->symtab[n]);
4057 if (addr > pc)
4058 {
4059 if (addr - pc < size)
4060 size = addr - pc;
4061 break;
4062 }
4063 }
4064 /* If the next symbol is after three bytes, we need to
4065 print only part of the data, so that we can use either
4066 .byte or .short. */
4067 if (size == 3)
4068 size = (pc & 1) ? 1 : 2;
4069 }
4070 }
4071
4072 if (info->symbols != NULL)
4073 {
4074 if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)
4075 {
4076 coff_symbol_type * cs;
4077
4078 cs = coffsymbol (*info->symbols);
4079 is_thumb = ( cs->native->u.syment.n_sclass == C_THUMBEXT
4080 || cs->native->u.syment.n_sclass == C_THUMBSTAT
4081 || cs->native->u.syment.n_sclass == C_THUMBLABEL
4082 || cs->native->u.syment.n_sclass == C_THUMBEXTFUNC
4083 || cs->native->u.syment.n_sclass == C_THUMBSTATFUNC);
4084 }
4085 else if (bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
4086 && !found)
4087 {
4088 /* If no mapping symbol has been found then fall back to the type
4089 of the function symbol. */
4090 elf_symbol_type * es;
4091 unsigned int type;
4092
4093 es = *(elf_symbol_type **)(info->symbols);
4094 type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
4095
4096 is_thumb = (type == STT_ARM_TFUNC) || (type == STT_ARM_16BIT);
4097 }
4098 }
4099
4100 if (force_thumb)
4101 is_thumb = TRUE;
4102
4103 info->display_endian = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;
4104 info->bytes_per_line = 4;
4105
4106 if (is_data)
4107 {
4108 int i;
4109
4110 /* size was already set above. */
4111 info->bytes_per_chunk = size;
4112 printer = print_insn_data;
4113
4114 status = info->read_memory_func (pc, (bfd_byte *)b, size, info);
4115 given = 0;
4116 if (little)
4117 for (i = size - 1; i >= 0; i--)
4118 given = b[i] | (given << 8);
4119 else
4120 for (i = 0; i < (int) size; i++)
4121 given = b[i] | (given << 8);
4122 }
4123 else if (!is_thumb)
4124 {
4125 /* In ARM mode endianness is a straightforward issue: the instruction
4126 is four bytes long and is either ordered 0123 or 3210. */
4127 printer = print_insn_arm;
4128 info->bytes_per_chunk = 4;
4129 size = 4;
4130
4131 status = info->read_memory_func (pc, (bfd_byte *)b, 4, info);
4132 if (little)
4133 given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
4134 else
4135 given = (b[3]) | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
4136 }
4137 else
4138 {
4139 /* In Thumb mode we have the additional wrinkle of two
4140 instruction lengths. Fortunately, the bits that determine
4141 the length of the current instruction are always to be found
4142 in the first two bytes. */
4143 printer = print_insn_thumb16;
4144 info->bytes_per_chunk = 2;
4145 size = 2;
4146
4147 status = info->read_memory_func (pc, (bfd_byte *)b, 2, info);
4148 if (little)
4149 given = (b[0]) | (b[1] << 8);
4150 else
4151 given = (b[1]) | (b[0] << 8);
4152
4153 if (!status)
4154 {
4155 /* These bit patterns signal a four-byte Thumb
4156 instruction. */
4157 if ((given & 0xF800) == 0xF800
4158 || (given & 0xF800) == 0xF000
4159 || (given & 0xF800) == 0xE800)
4160 {
4161 status = info->read_memory_func (pc + 2, (bfd_byte *)b, 2, info);
4162 if (little)
4163 given = (b[0]) | (b[1] << 8) | (given << 16);
4164 else
4165 given = (b[1]) | (b[0] << 8) | (given << 16);
4166
4167 printer = print_insn_thumb32;
4168 size = 4;
4169 }
4170 }
4171
4172 if (ifthen_address != pc)
4173 find_ifthen_state(pc, info, little);
4174
4175 if (ifthen_state)
4176 {
4177 if ((ifthen_state & 0xf) == 0x8)
4178 ifthen_next_state = 0;
4179 else
4180 ifthen_next_state = (ifthen_state & 0xe0)
4181 | ((ifthen_state & 0xf) << 1);
4182 }
4183 }
4184
4185 if (status)
4186 {
4187 info->memory_error_func (status, pc, info);
4188 return -1;
4189 }
4190 if (info->flags & INSN_HAS_RELOC)
4191 /* If the instruction has a reloc associated with it, then
4192 the offset field in the instruction will actually be the
4193 addend for the reloc. (We are using REL type relocs).
4194 In such cases, we can ignore the pc when computing
4195 addresses, since the addend is not currently pc-relative. */
4196 pc = 0;
4197
4198 printer (pc, info, given);
4199
4200 if (is_thumb)
4201 {
4202 ifthen_state = ifthen_next_state;
4203 ifthen_address += size;
4204 }
4205 return size;
4206 }
4207
4208 int
print_insn_big_arm(bfd_vma pc,struct disassemble_info * info)4209 print_insn_big_arm (bfd_vma pc, struct disassemble_info *info)
4210 {
4211 return print_insn (pc, info, FALSE);
4212 }
4213
4214 int
print_insn_little_arm(bfd_vma pc,struct disassemble_info * info)4215 print_insn_little_arm (bfd_vma pc, struct disassemble_info *info)
4216 {
4217 return print_insn (pc, info, TRUE);
4218 }
4219
4220 void
print_arm_disassembler_options(FILE * stream)4221 print_arm_disassembler_options (FILE *stream)
4222 {
4223 int i;
4224
4225 fprintf (stream, _("\n\
4226 The following ARM specific disassembler options are supported for use with\n\
4227 the -M switch:\n"));
4228
4229 for (i = NUM_ARM_REGNAMES; i--;)
4230 fprintf (stream, " reg-names-%s %*c%s\n",
4231 regnames[i].name,
4232 (int)(14 - strlen (regnames[i].name)), ' ',
4233 regnames[i].description);
4234
4235 fprintf (stream, " force-thumb Assume all insns are Thumb insns\n");
4236 fprintf (stream, " no-force-thumb Examine preceeding label to determine an insn's type\n\n");
4237 }
4238