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