opcodes/arm-dis.c

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