opcodes/arm-dis.c

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