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