OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [arm-dis.c] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.