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        %a               print the address of a plain load/store
1340        %w               print the width and signedness of a core load/store
1341        %m               print register mask for ldm/stm
1342
1343        %E               print the lsb and width fields of a bfc/bfi instruction
1344        %F               print the lsb and width fields of a sbfx/ubfx instruction
1345        %b               print a conditional branch offset
1346        %B               print an unconditional branch offset
1347        %s               print the shift field of an SSAT instruction
1348        %R               print the rotation field of an SXT instruction
1349        %U               print barrier type.
1350        %P               print address for pli instruction.
1351        %c               print the condition code
1352        %x               print warning if conditional an not at end of IT block"
1353        %X               print "\t; unpredictable <IT:code>" if conditional
1354
1355        %<bitfield>d     print bitfield in decimal
1356        %<bitfield>W     print bitfield*4 in decimal
1357        %<bitfield>r     print bitfield as an ARM register
1358        %<bitfield>R     as %<>r bit r15 is UNPREDICTABLE
1359        %<bitfield>c     print bitfield as a condition code
1360
1361        %<bitfield>'c    print specified char iff bitfield is all ones
1362        %<bitfield>`c    print specified char iff bitfield is all zeroes
1363        %<bitfield>?ab... select from array of values in big endian order
1364
1365    With one exception at the bottom (done because BL and BLX(1) need
1366    to come dead last), this table was machine-sorted first in
1367    decreasing order of number of bits set in the mask, then in
1368    increasing numeric order of mask, then in increasing numeric order
1369    of opcode.  This order is not the clearest for a human reader, but
1370    is guaranteed never to catch a special-case bit pattern with a more
1371    general mask, which is important, because this instruction encoding
1372    makes heavy use of special-case bit patterns.  */
1373 static const struct opcode32 thumb32_opcodes[] =
1374 {
1375   /* V7 instructions.  */
1376   {ARM_EXT_V7, 0xf910f000, 0xff70f000, "pli%c\t%a"},
1377   {ARM_EXT_V7, 0xf3af80f0, 0xfffffff0, "dbg%c\t#%0-3d"},
1378   {ARM_EXT_V7, 0xf3bf8f50, 0xfffffff0, "dmb%c\t%U"},
1379   {ARM_EXT_V7, 0xf3bf8f40, 0xfffffff0, "dsb%c\t%U"},
1380   {ARM_EXT_V7, 0xf3bf8f60, 0xfffffff0, "isb%c\t%U"},
1381   {ARM_EXT_DIV, 0xfb90f0f0, 0xfff0f0f0, "sdiv%c\t%8-11r, %16-19r, %0-3r"},
1382   {ARM_EXT_DIV, 0xfbb0f0f0, 0xfff0f0f0, "udiv%c\t%8-11r, %16-19r, %0-3r"},
1383
1384   /* Virtualization Extension instructions.  */
1385   {ARM_EXT_VIRT, 0xf7e08000, 0xfff0f000, "hvc%c\t%V"},
1386   /* We skip ERET as that is SUBS pc, lr, #0.  */
1387
1388   /* MP Extension instructions.  */
1389   {ARM_EXT_MP,   0xf830f000, 0xff70f000, "pldw%c\t%a"},
1390
1391   /* Security extension instructions.  */
1392   {ARM_EXT_SEC,  0xf7f08000, 0xfff0f000, "smc%c\t%K"},
1393
1394   /* Instructions defined in the basic V6T2 set.  */
1395   {ARM_EXT_V6T2, 0xf3af8000, 0xffffffff, "nop%c.w"},
1396   {ARM_EXT_V6T2, 0xf3af8001, 0xffffffff, "yield%c.w"},
1397   {ARM_EXT_V6T2, 0xf3af8002, 0xffffffff, "wfe%c.w"},
1398   {ARM_EXT_V6T2, 0xf3af8003, 0xffffffff, "wfi%c.w"},
1399   {ARM_EXT_V6T2, 0xf3af8004, 0xffffffff, "sev%c.w"},
1400   {ARM_EXT_V6T2, 0xf3af8000, 0xffffff00, "nop%c.w\t{%0-7d}"},
1401
1402   {ARM_EXT_V6T2, 0xf3bf8f2f, 0xffffffff, "clrex%c"},
1403   {ARM_EXT_V6T2, 0xf3af8400, 0xffffff1f, "cpsie.w\t%7'a%6'i%5'f%X"},
1404   {ARM_EXT_V6T2, 0xf3af8600, 0xffffff1f, "cpsid.w\t%7'a%6'i%5'f%X"},
1405   {ARM_EXT_V6T2, 0xf3c08f00, 0xfff0ffff, "bxj%c\t%16-19r%x"},
1406   {ARM_EXT_V6T2, 0xe810c000, 0xffd0ffff, "rfedb%c\t%16-19r%21'!"},
1407   {ARM_EXT_V6T2, 0xe990c000, 0xffd0ffff, "rfeia%c\t%16-19r%21'!"},
1408   {ARM_EXT_V6T2, 0xf3e08000, 0xffe0f000, "mrs%c\t%8-11r, %D"},
1409   {ARM_EXT_V6T2, 0xf3af8100, 0xffffffe0, "cps\t#%0-4d%X"},
1410   {ARM_EXT_V6T2, 0xe8d0f000, 0xfff0fff0, "tbb%c\t[%16-19r, %0-3r]%x"},
1411   {ARM_EXT_V6T2, 0xe8d0f010, 0xfff0fff0, "tbh%c\t[%16-19r, %0-3r, lsl #1]%x"},
1412   {ARM_EXT_V6T2, 0xf3af8500, 0xffffff00, "cpsie\t%7'a%6'i%5'f, #%0-4d%X"},
1413   {ARM_EXT_V6T2, 0xf3af8700, 0xffffff00, "cpsid\t%7'a%6'i%5'f, #%0-4d%X"},
1414   {ARM_EXT_V6T2, 0xf3de8f00, 0xffffff00, "subs%c\tpc, lr, #%0-7d"},
1415   {ARM_EXT_V6T2, 0xf3808000, 0xffe0f000, "msr%c\t%C, %16-19r"},
1416   {ARM_EXT_V6T2, 0xe8500f00, 0xfff00fff, "ldrex%c\t%12-15r, [%16-19r]"},
1417   {ARM_EXT_V6T2, 0xe8d00f4f, 0xfff00fef, "ldrex%4?hb%c\t%12-15r, [%16-19r]"},
1418   {ARM_EXT_V6T2, 0xe800c000, 0xffd0ffe0, "srsdb%c\t%16-19r%21'!, #%0-4d"},
1419   {ARM_EXT_V6T2, 0xe980c000, 0xffd0ffe0, "srsia%c\t%16-19r%21'!, #%0-4d"},
1420   {ARM_EXT_V6T2, 0xfa0ff080, 0xfffff0c0, "sxth%c.w\t%8-11r, %0-3r%R"},
1421   {ARM_EXT_V6T2, 0xfa1ff080, 0xfffff0c0, "uxth%c.w\t%8-11r, %0-3r%R"},
1422   {ARM_EXT_V6T2, 0xfa2ff080, 0xfffff0c0, "sxtb16%c\t%8-11r, %0-3r%R"},
1423   {ARM_EXT_V6T2, 0xfa3ff080, 0xfffff0c0, "uxtb16%c\t%8-11r, %0-3r%R"},
1424   {ARM_EXT_V6T2, 0xfa4ff080, 0xfffff0c0, "sxtb%c.w\t%8-11r, %0-3r%R"},
1425   {ARM_EXT_V6T2, 0xfa5ff080, 0xfffff0c0, "uxtb%c.w\t%8-11r, %0-3r%R"},
1426   {ARM_EXT_V6T2, 0xe8400000, 0xfff000ff, "strex%c\t%8-11r, %12-15r, [%16-19r]"},
1427   {ARM_EXT_V6T2, 0xe8d0007f, 0xfff000ff, "ldrexd%c\t%12-15r, %8-11r, [%16-19r]"},
1428   {ARM_EXT_V6T2, 0xfa80f000, 0xfff0f0f0, "sadd8%c\t%8-11r, %16-19r, %0-3r"},
1429   {ARM_EXT_V6T2, 0xfa80f010, 0xfff0f0f0, "qadd8%c\t%8-11r, %16-19r, %0-3r"},
1430   {ARM_EXT_V6T2, 0xfa80f020, 0xfff0f0f0, "shadd8%c\t%8-11r, %16-19r, %0-3r"},
1431   {ARM_EXT_V6T2, 0xfa80f040, 0xfff0f0f0, "uadd8%c\t%8-11r, %16-19r, %0-3r"},
1432   {ARM_EXT_V6T2, 0xfa80f050, 0xfff0f0f0, "uqadd8%c\t%8-11r, %16-19r, %0-3r"},
1433   {ARM_EXT_V6T2, 0xfa80f060, 0xfff0f0f0, "uhadd8%c\t%8-11r, %16-19r, %0-3r"},
1434   {ARM_EXT_V6T2, 0xfa80f080, 0xfff0f0f0, "qadd%c\t%8-11r, %0-3r, %16-19r"},
1435   {ARM_EXT_V6T2, 0xfa80f090, 0xfff0f0f0, "qdadd%c\t%8-11r, %0-3r, %16-19r"},
1436   {ARM_EXT_V6T2, 0xfa80f0a0, 0xfff0f0f0, "qsub%c\t%8-11r, %0-3r, %16-19r"},
1437   {ARM_EXT_V6T2, 0xfa80f0b0, 0xfff0f0f0, "qdsub%c\t%8-11r, %0-3r, %16-19r"},
1438   {ARM_EXT_V6T2, 0xfa90f000, 0xfff0f0f0, "sadd16%c\t%8-11r, %16-19r, %0-3r"},
1439   {ARM_EXT_V6T2, 0xfa90f010, 0xfff0f0f0, "qadd16%c\t%8-11r, %16-19r, %0-3r"},
1440   {ARM_EXT_V6T2, 0xfa90f020, 0xfff0f0f0, "shadd16%c\t%8-11r, %16-19r, %0-3r"},
1441   {ARM_EXT_V6T2, 0xfa90f040, 0xfff0f0f0, "uadd16%c\t%8-11r, %16-19r, %0-3r"},
1442   {ARM_EXT_V6T2, 0xfa90f050, 0xfff0f0f0, "uqadd16%c\t%8-11r, %16-19r, %0-3r"},
1443   {ARM_EXT_V6T2, 0xfa90f060, 0xfff0f0f0, "uhadd16%c\t%8-11r, %16-19r, %0-3r"},
1444   {ARM_EXT_V6T2, 0xfa90f080, 0xfff0f0f0, "rev%c.w\t%8-11r, %16-19r"},
1445   {ARM_EXT_V6T2, 0xfa90f090, 0xfff0f0f0, "rev16%c.w\t%8-11r, %16-19r"},
1446   {ARM_EXT_V6T2, 0xfa90f0a0, 0xfff0f0f0, "rbit%c\t%8-11r, %16-19r"},
1447   {ARM_EXT_V6T2, 0xfa90f0b0, 0xfff0f0f0, "revsh%c.w\t%8-11r, %16-19r"},
1448   {ARM_EXT_V6T2, 0xfaa0f000, 0xfff0f0f0, "sasx%c\t%8-11r, %16-19r, %0-3r"},
1449   {ARM_EXT_V6T2, 0xfaa0f010, 0xfff0f0f0, "qasx%c\t%8-11r, %16-19r, %0-3r"},
1450   {ARM_EXT_V6T2, 0xfaa0f020, 0xfff0f0f0, "shasx%c\t%8-11r, %16-19r, %0-3r"},
1451   {ARM_EXT_V6T2, 0xfaa0f040, 0xfff0f0f0, "uasx%c\t%8-11r, %16-19r, %0-3r"},
1452   {ARM_EXT_V6T2, 0xfaa0f050, 0xfff0f0f0, "uqasx%c\t%8-11r, %16-19r, %0-3r"},
1453   {ARM_EXT_V6T2, 0xfaa0f060, 0xfff0f0f0, "uhasx%c\t%8-11r, %16-19r, %0-3r"},
1454   {ARM_EXT_V6T2, 0xfaa0f080, 0xfff0f0f0, "sel%c\t%8-11r, %16-19r, %0-3r"},
1455   {ARM_EXT_V6T2, 0xfab0f080, 0xfff0f0f0, "clz%c\t%8-11r, %16-19r"},
1456   {ARM_EXT_V6T2, 0xfac0f000, 0xfff0f0f0, "ssub8%c\t%8-11r, %16-19r, %0-3r"},
1457   {ARM_EXT_V6T2, 0xfac0f010, 0xfff0f0f0, "qsub8%c\t%8-11r, %16-19r, %0-3r"},
1458   {ARM_EXT_V6T2, 0xfac0f020, 0xfff0f0f0, "shsub8%c\t%8-11r, %16-19r, %0-3r"},
1459   {ARM_EXT_V6T2, 0xfac0f040, 0xfff0f0f0, "usub8%c\t%8-11r, %16-19r, %0-3r"},
1460   {ARM_EXT_V6T2, 0xfac0f050, 0xfff0f0f0, "uqsub8%c\t%8-11r, %16-19r, %0-3r"},
1461   {ARM_EXT_V6T2, 0xfac0f060, 0xfff0f0f0, "uhsub8%c\t%8-11r, %16-19r, %0-3r"},
1462   {ARM_EXT_V6T2, 0xfad0f000, 0xfff0f0f0, "ssub16%c\t%8-11r, %16-19r, %0-3r"},
1463   {ARM_EXT_V6T2, 0xfad0f010, 0xfff0f0f0, "qsub16%c\t%8-11r, %16-19r, %0-3r"},
1464   {ARM_EXT_V6T2, 0xfad0f020, 0xfff0f0f0, "shsub16%c\t%8-11r, %16-19r, %0-3r"},
1465   {ARM_EXT_V6T2, 0xfad0f040, 0xfff0f0f0, "usub16%c\t%8-11r, %16-19r, %0-3r"},
1466   {ARM_EXT_V6T2, 0xfad0f050, 0xfff0f0f0, "uqsub16%c\t%8-11r, %16-19r, %0-3r"},
1467   {ARM_EXT_V6T2, 0xfad0f060, 0xfff0f0f0, "uhsub16%c\t%8-11r, %16-19r, %0-3r"},
1468   {ARM_EXT_V6T2, 0xfae0f000, 0xfff0f0f0, "ssax%c\t%8-11r, %16-19r, %0-3r"},
1469   {ARM_EXT_V6T2, 0xfae0f010, 0xfff0f0f0, "qsax%c\t%8-11r, %16-19r, %0-3r"},
1470   {ARM_EXT_V6T2, 0xfae0f020, 0xfff0f0f0, "shsax%c\t%8-11r, %16-19r, %0-3r"},
1471   {ARM_EXT_V6T2, 0xfae0f040, 0xfff0f0f0, "usax%c\t%8-11r, %16-19r, %0-3r"},
1472   {ARM_EXT_V6T2, 0xfae0f050, 0xfff0f0f0, "uqsax%c\t%8-11r, %16-19r, %0-3r"},
1473   {ARM_EXT_V6T2, 0xfae0f060, 0xfff0f0f0, "uhsax%c\t%8-11r, %16-19r, %0-3r"},
1474   {ARM_EXT_V6T2, 0xfb00f000, 0xfff0f0f0, "mul%c.w\t%8-11r, %16-19r, %0-3r"},
1475   {ARM_EXT_V6T2, 0xfb70f000, 0xfff0f0f0, "usad8%c\t%8-11r, %16-19r, %0-3r"},
1476   {ARM_EXT_V6T2, 0xfa00f000, 0xffe0f0f0, "lsl%20's%c.w\t%8-11R, %16-19R, %0-3R"},
1477   {ARM_EXT_V6T2, 0xfa20f000, 0xffe0f0f0, "lsr%20's%c.w\t%8-11R, %16-19R, %0-3R"},
1478   {ARM_EXT_V6T2, 0xfa40f000, 0xffe0f0f0, "asr%20's%c.w\t%8-11R, %16-19R, %0-3R"},
1479   {ARM_EXT_V6T2, 0xfa60f000, 0xffe0f0f0, "ror%20's%c.w\t%8-11r, %16-19r, %0-3r"},
1480   {ARM_EXT_V6T2, 0xe8c00f40, 0xfff00fe0, "strex%4?hb%c\t%0-3r, %12-15r, [%16-19r]"},
1481   {ARM_EXT_V6T2, 0xf3200000, 0xfff0f0e0, "ssat16%c\t%8-11r, #%0-4d, %16-19r"},
1482   {ARM_EXT_V6T2, 0xf3a00000, 0xfff0f0e0, "usat16%c\t%8-11r, #%0-4d, %16-19r"},
1483   {ARM_EXT_V6T2, 0xfb20f000, 0xfff0f0e0, "smuad%4'x%c\t%8-11r, %16-19r, %0-3r"},
1484   {ARM_EXT_V6T2, 0xfb30f000, 0xfff0f0e0, "smulw%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1485   {ARM_EXT_V6T2, 0xfb40f000, 0xfff0f0e0, "smusd%4'x%c\t%8-11r, %16-19r, %0-3r"},
1486   {ARM_EXT_V6T2, 0xfb50f000, 0xfff0f0e0, "smmul%4'r%c\t%8-11r, %16-19r, %0-3r"},
1487   {ARM_EXT_V6T2, 0xfa00f080, 0xfff0f0c0, "sxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1488   {ARM_EXT_V6T2, 0xfa10f080, 0xfff0f0c0, "uxtah%c\t%8-11r, %16-19r, %0-3r%R"},
1489   {ARM_EXT_V6T2, 0xfa20f080, 0xfff0f0c0, "sxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1490   {ARM_EXT_V6T2, 0xfa30f080, 0xfff0f0c0, "uxtab16%c\t%8-11r, %16-19r, %0-3r%R"},
1491   {ARM_EXT_V6T2, 0xfa40f080, 0xfff0f0c0, "sxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1492   {ARM_EXT_V6T2, 0xfa50f080, 0xfff0f0c0, "uxtab%c\t%8-11r, %16-19r, %0-3r%R"},
1493   {ARM_EXT_V6T2, 0xfb10f000, 0xfff0f0c0, "smul%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r"},
1494   {ARM_EXT_V6T2, 0xf36f0000, 0xffff8020, "bfc%c\t%8-11r, %E"},
1495   {ARM_EXT_V6T2, 0xea100f00, 0xfff08f00, "tst%c.w\t%16-19r, %S"},
1496   {ARM_EXT_V6T2, 0xea900f00, 0xfff08f00, "teq%c\t%16-19r, %S"},
1497   {ARM_EXT_V6T2, 0xeb100f00, 0xfff08f00, "cmn%c.w\t%16-19r, %S"},
1498   {ARM_EXT_V6T2, 0xebb00f00, 0xfff08f00, "cmp%c.w\t%16-19r, %S"},
1499   {ARM_EXT_V6T2, 0xf0100f00, 0xfbf08f00, "tst%c.w\t%16-19r, %M"},
1500   {ARM_EXT_V6T2, 0xf0900f00, 0xfbf08f00, "teq%c\t%16-19r, %M"},
1501   {ARM_EXT_V6T2, 0xf1100f00, 0xfbf08f00, "cmn%c.w\t%16-19r, %M"},
1502   {ARM_EXT_V6T2, 0xf1b00f00, 0xfbf08f00, "cmp%c.w\t%16-19r, %M"},
1503   {ARM_EXT_V6T2, 0xea4f0000, 0xffef8000, "mov%20's%c.w\t%8-11r, %S"},
1504   {ARM_EXT_V6T2, 0xea6f0000, 0xffef8000, "mvn%20's%c.w\t%8-11r, %S"},
1505   {ARM_EXT_V6T2, 0xe8c00070, 0xfff000f0, "strexd%c\t%0-3r, %12-15r, %8-11r, [%16-19r]"},
1506   {ARM_EXT_V6T2, 0xfb000000, 0xfff000f0, "mla%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1507   {ARM_EXT_V6T2, 0xfb000010, 0xfff000f0, "mls%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1508   {ARM_EXT_V6T2, 0xfb700000, 0xfff000f0, "usada8%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1509   {ARM_EXT_V6T2, 0xfb800000, 0xfff000f0, "smull%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1510   {ARM_EXT_V6T2, 0xfba00000, 0xfff000f0, "umull%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1511   {ARM_EXT_V6T2, 0xfbc00000, 0xfff000f0, "smlal%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1512   {ARM_EXT_V6T2, 0xfbe00000, 0xfff000f0, "umlal%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1513   {ARM_EXT_V6T2, 0xfbe00060, 0xfff000f0, "umaal%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1514   {ARM_EXT_V6T2, 0xe8500f00, 0xfff00f00, "ldrex%c\t%12-15r, [%16-19r, #%0-7W]"},
1515   {ARM_EXT_V6T2, 0xf04f0000, 0xfbef8000, "mov%20's%c.w\t%8-11r, %M"},
1516   {ARM_EXT_V6T2, 0xf06f0000, 0xfbef8000, "mvn%20's%c.w\t%8-11r, %M"},
1517   {ARM_EXT_V6T2, 0xf810f000, 0xff70f000, "pld%c\t%a"},
1518   {ARM_EXT_V6T2, 0xfb200000, 0xfff000e0, "smlad%4'x%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1519   {ARM_EXT_V6T2, 0xfb300000, 0xfff000e0, "smlaw%4?tb%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1520   {ARM_EXT_V6T2, 0xfb400000, 0xfff000e0, "smlsd%4'x%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1521   {ARM_EXT_V6T2, 0xfb500000, 0xfff000e0, "smmla%4'r%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1522   {ARM_EXT_V6T2, 0xfb600000, 0xfff000e0, "smmls%4'r%c\t%8-11R, %16-19R, %0-3R, %12-15R"},
1523   {ARM_EXT_V6T2, 0xfbc000c0, 0xfff000e0, "smlald%4'x%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1524   {ARM_EXT_V6T2, 0xfbd000c0, 0xfff000e0, "smlsld%4'x%c\t%12-15R, %8-11R, %16-19R, %0-3R"},
1525   {ARM_EXT_V6T2, 0xeac00000, 0xfff08030, "pkhbt%c\t%8-11r, %16-19r, %S"},
1526   {ARM_EXT_V6T2, 0xeac00020, 0xfff08030, "pkhtb%c\t%8-11r, %16-19r, %S"},
1527   {ARM_EXT_V6T2, 0xf3400000, 0xfff08020, "sbfx%c\t%8-11r, %16-19r, %F"},
1528   {ARM_EXT_V6T2, 0xf3c00000, 0xfff08020, "ubfx%c\t%8-11r, %16-19r, %F"},
1529   {ARM_EXT_V6T2, 0xf8000e00, 0xff900f00, "str%wt%c\t%12-15r, %a"},
1530   {ARM_EXT_V6T2, 0xfb100000, 0xfff000c0, "smla%5?tb%4?tb%c\t%8-11r, %16-19r, %0-3r, %12-15r"},
1531   {ARM_EXT_V6T2, 0xfbc00080, 0xfff000c0, "smlal%5?tb%4?tb%c\t%12-15r, %8-11r, %16-19r, %0-3r"},
1532   {ARM_EXT_V6T2, 0xf3600000, 0xfff08020, "bfi%c\t%8-11r, %16-19r, %E"},
1533   {ARM_EXT_V6T2, 0xf8100e00, 0xfe900f00, "ldr%wt%c\t%12-15r, %a"},
1534   {ARM_EXT_V6T2, 0xf3000000, 0xffd08020, "ssat%c\t%8-11r, #%0-4d, %16-19r%s"},
1535   {ARM_EXT_V6T2, 0xf3800000, 0xffd08020, "usat%c\t%8-11r, #%0-4d, %16-19r%s"},
1536   {ARM_EXT_V6T2, 0xf2000000, 0xfbf08000, "addw%c\t%8-11r, %16-19r, %I"},
1537   {ARM_EXT_V6T2, 0xf2400000, 0xfbf08000, "movw%c\t%8-11r, %J"},
1538   {ARM_EXT_V6T2, 0xf2a00000, 0xfbf08000, "subw%c\t%8-11r, %16-19r, %I"},
1539   {ARM_EXT_V6T2, 0xf2c00000, 0xfbf08000, "movt%c\t%8-11r, %J"},
1540   {ARM_EXT_V6T2, 0xea000000, 0xffe08000, "and%20's%c.w\t%8-11r, %16-19r, %S"},
1541   {ARM_EXT_V6T2, 0xea200000, 0xffe08000, "bic%20's%c.w\t%8-11r, %16-19r, %S"},
1542   {ARM_EXT_V6T2, 0xea400000, 0xffe08000, "orr%20's%c.w\t%8-11r, %16-19r, %S"},
1543   {ARM_EXT_V6T2, 0xea600000, 0xffe08000, "orn%20's%c\t%8-11r, %16-19r, %S"},
1544   {ARM_EXT_V6T2, 0xea800000, 0xffe08000, "eor%20's%c.w\t%8-11r, %16-19r, %S"},
1545   {ARM_EXT_V6T2, 0xeb000000, 0xffe08000, "add%20's%c.w\t%8-11r, %16-19r, %S"},
1546   {ARM_EXT_V6T2, 0xeb400000, 0xffe08000, "adc%20's%c.w\t%8-11r, %16-19r, %S"},
1547   {ARM_EXT_V6T2, 0xeb600000, 0xffe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %S"},
1548   {ARM_EXT_V6T2, 0xeba00000, 0xffe08000, "sub%20's%c.w\t%8-11r, %16-19r, %S"},
1549   {ARM_EXT_V6T2, 0xebc00000, 0xffe08000, "rsb%20's%c\t%8-11r, %16-19r, %S"},
1550   {ARM_EXT_V6T2, 0xe8400000, 0xfff00000, "strex%c\t%8-11r, %12-15r, [%16-19r, #%0-7W]"},
1551   {ARM_EXT_V6T2, 0xf0000000, 0xfbe08000, "and%20's%c.w\t%8-11r, %16-19r, %M"},
1552   {ARM_EXT_V6T2, 0xf0200000, 0xfbe08000, "bic%20's%c.w\t%8-11r, %16-19r, %M"},
1553   {ARM_EXT_V6T2, 0xf0400000, 0xfbe08000, "orr%20's%c.w\t%8-11r, %16-19r, %M"},
1554   {ARM_EXT_V6T2, 0xf0600000, 0xfbe08000, "orn%20's%c\t%8-11r, %16-19r, %M"},
1555   {ARM_EXT_V6T2, 0xf0800000, 0xfbe08000, "eor%20's%c.w\t%8-11r, %16-19r, %M"},
1556   {ARM_EXT_V6T2, 0xf1000000, 0xfbe08000, "add%20's%c.w\t%8-11r, %16-19r, %M"},
1557   {ARM_EXT_V6T2, 0xf1400000, 0xfbe08000, "adc%20's%c.w\t%8-11r, %16-19r, %M"},
1558   {ARM_EXT_V6T2, 0xf1600000, 0xfbe08000, "sbc%20's%c.w\t%8-11r, %16-19r, %M"},
1559   {ARM_EXT_V6T2, 0xf1a00000, 0xfbe08000, "sub%20's%c.w\t%8-11r, %16-19r, %M"},
1560   {ARM_EXT_V6T2, 0xf1c00000, 0xfbe08000, "rsb%20's%c\t%8-11r, %16-19r, %M"},
1561   {ARM_EXT_V6T2, 0xe8800000, 0xffd00000, "stmia%c.w\t%16-19r%21'!, %m"},
1562   {ARM_EXT_V6T2, 0xe8900000, 0xffd00000, "ldmia%c.w\t%16-19r%21'!, %m"},
1563   {ARM_EXT_V6T2, 0xe9000000, 0xffd00000, "stmdb%c\t%16-19r%21'!, %m"},
1564   {ARM_EXT_V6T2, 0xe9100000, 0xffd00000, "ldmdb%c\t%16-19r%21'!, %m"},
1565   {ARM_EXT_V6T2, 0xe9c00000, 0xffd000ff, "strd%c\t%12-15r, %8-11r, [%16-19r]"},
1566   {ARM_EXT_V6T2, 0xe9d00000, 0xffd000ff, "ldrd%c\t%12-15r, %8-11r, [%16-19r]"},
1567   {ARM_EXT_V6T2, 0xe9400000, 0xff500000, "strd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1568   {ARM_EXT_V6T2, 0xe9500000, 0xff500000, "ldrd%c\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]%21'!"},
1569   {ARM_EXT_V6T2, 0xe8600000, 0xff700000, "strd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1570   {ARM_EXT_V6T2, 0xe8700000, 0xff700000, "ldrd%c\t%12-15r, %8-11r, [%16-19r], #%23`-%0-7W"},
1571   {ARM_EXT_V6T2, 0xf8000000, 0xff100000, "str%w%c.w\t%12-15r, %a"},
1572   {ARM_EXT_V6T2, 0xf8100000, 0xfe100000, "ldr%w%c.w\t%12-15r, %a"},
1573
1574   /* Filter out Bcc with cond=E or F, which are used for other instructions.  */
1575   {ARM_EXT_V6T2, 0xf3c08000, 0xfbc0d000, "undefined (bcc, cond=0xF)"},
1576   {ARM_EXT_V6T2, 0xf3808000, 0xfbc0d000, "undefined (bcc, cond=0xE)"},
1577   {ARM_EXT_V6T2, 0xf0008000, 0xf800d000, "b%22-25c.w\t%b%X"},
1578   {ARM_EXT_V6T2, 0xf0009000, 0xf800d000, "b%c.w\t%B%x"},
1579
1580   /* These have been 32-bit since the invention of Thumb.  */
1581   {ARM_EXT_V4T,  0xf000c000, 0xf800d001, "blx%c\t%B%x"},
1582   {ARM_EXT_V4T,  0xf000d000, 0xf800d000, "bl%c\t%B%x"},
1583
1584   /* Fallback.  */
1585   {ARM_EXT_V1,   0x00000000, 0x00000000, UNDEFINED_INSTRUCTION},
1586   {0, 0, 0, 0}
1587 };
1588
1589 static const char *const arm_conditional[] =
1590 {"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
1591  "hi", "ls", "ge", "lt", "gt", "le", "al", "<und>", ""};
1592
1593 static const char *const arm_fp_const[] =
1594 {"0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0"};
1595
1596 static const char *const arm_shift[] =
1597 {"lsl", "lsr", "asr", "ror"};
1598
1599 typedef struct
1600 {
1601   const char *name;
1602   const char *description;
1603   const char *reg_names[16];
1604 }
1605 arm_regname;
1606
1607 static const arm_regname regnames[] =
1608 {
1609   { "raw" , "Select raw register names",
1610     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"}},
1611   { "gcc",  "Select register names used by GCC",
1612     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1613   { "std",  "Select register names used in ARM's ISA documentation",
1614     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "sp",  "lr",  "pc" }},
1615   { "apcs", "Select register names used in the APCS",
1616     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1617   { "atpcs", "Select register names used in the ATPCS",
1618     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "v7",  "v8",  "IP",  "SP",  "LR",  "PC" }},
1619   { "special-atpcs", "Select special register names used in the ATPCS",
1620     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "WR", "v5", "SB", "SL",  "FP",  "IP",  "SP",  "LR",  "PC" }},
1621 };
1622
1623 static const char *const iwmmxt_wwnames[] =
1624 {"b", "h", "w", "d"};
1625
1626 static const char *const iwmmxt_wwssnames[] =
1627 {"b", "bus", "bc", "bss",
1628  "h", "hus", "hc", "hss",
1629  "w", "wus", "wc", "wss",
1630  "d", "dus", "dc", "dss"
1631 };
1632
1633 static const char *const iwmmxt_regnames[] =
1634 { "wr0", "wr1", "wr2", "wr3", "wr4", "wr5", "wr6", "wr7",
1635   "wr8", "wr9", "wr10", "wr11", "wr12", "wr13", "wr14", "wr15"
1636 };
1637
1638 static const char *const iwmmxt_cregnames[] =
1639 { "wcid", "wcon", "wcssf", "wcasf", "reserved", "reserved", "reserved", "reserved",
1640   "wcgr0", "wcgr1", "wcgr2", "wcgr3", "reserved", "reserved", "reserved", "reserved"
1641 };
1642
1643 /* Default to GCC register name set.  */
1644 static unsigned int regname_selected = 1;
1645
1646 #define NUM_ARM_REGNAMES  NUM_ELEM (regnames)
1647 #define arm_regnames      regnames[regname_selected].reg_names
1648
1649 static bfd_boolean force_thumb = FALSE;
1650
1651 /* Current IT instruction state.  This contains the same state as the IT
1652    bits in the CPSR.  */
1653 static unsigned int ifthen_state;
1654 /* IT state for the next instruction.  */
1655 static unsigned int ifthen_next_state;
1656 /* The address of the insn for which the IT state is valid.  */
1657 static bfd_vma ifthen_address;
1658 #define IFTHEN_COND ((ifthen_state >> 4) & 0xf)
1659
1660 \f
1661 /* Functions.  */
1662 int
1663 get_arm_regname_num_options (void)
1664 {
1665   return NUM_ARM_REGNAMES;
1666 }
1667
1668 int
1669 set_arm_regname_option (int option)
1670 {
1671   int old = regname_selected;
1672   regname_selected = option;
1673   return old;
1674 }
1675
1676 int
1677 get_arm_regnames (int option,
1678                   const char **setname,
1679                   const char **setdescription,
1680                   const char *const **register_names)
1681 {
1682   *setname = regnames[option].name;
1683   *setdescription = regnames[option].description;
1684   *register_names = regnames[option].reg_names;
1685   return 16;
1686 }
1687
1688 /* Decode a bitfield of the form matching regexp (N(-N)?,)*N(-N)?.
1689    Returns pointer to following character of the format string and
1690    fills in *VALUEP and *WIDTHP with the extracted value and number of
1691    bits extracted.  WIDTHP can be NULL.  */
1692
1693 static const char *
1694 arm_decode_bitfield (const char *ptr,
1695                      unsigned long insn,
1696                      unsigned long *valuep,
1697                      int *widthp)
1698 {
1699   unsigned long value = 0;
1700   int width = 0;
1701
1702   do
1703     {
1704       int start, end;
1705       int bits;
1706
1707       for (start = 0; *ptr >= '0' && *ptr <= '9'; ptr++)
1708         start = start * 10 + *ptr - '0';
1709       if (*ptr == '-')
1710         for (end = 0, ptr++; *ptr >= '0' && *ptr <= '9'; ptr++)
1711           end = end * 10 + *ptr - '0';
1712       else
1713         end = start;
1714       bits = end - start;
1715       if (bits < 0)
1716         abort ();
1717       value |= ((insn >> start) & ((2ul << bits) - 1)) << width;
1718       width += bits + 1;
1719     }
1720   while (*ptr++ == ',');
1721   *valuep = value;
1722   if (widthp)
1723     *widthp = width;
1724   return ptr - 1;
1725 }
1726
1727 static void
1728 arm_decode_shift (long given, fprintf_ftype func, void *stream,
1729                   bfd_boolean print_shift)
1730 {
1731   func (stream, "%s", arm_regnames[given & 0xf]);
1732
1733   if ((given & 0xff0) != 0)
1734     {
1735       if ((given & 0x10) == 0)
1736         {
1737           int amount = (given & 0xf80) >> 7;
1738           int shift = (given & 0x60) >> 5;
1739
1740           if (amount == 0)
1741             {
1742               if (shift == 3)
1743                 {
1744                   func (stream, ", rrx");
1745                   return;
1746                 }
1747
1748               amount = 32;
1749             }
1750
1751           if (print_shift)
1752             func (stream, ", %s #%d", arm_shift[shift], amount);
1753           else
1754             func (stream, ", #%d", amount);
1755         }
1756       else if ((given & 0x80) == 0x80)
1757         func (stream, "\t; <illegal shifter operand>");
1758       else if (print_shift)
1759         func (stream, ", %s %s", arm_shift[(given & 0x60) >> 5],
1760               arm_regnames[(given & 0xf00) >> 8]);
1761       else
1762         func (stream, ", %s", arm_regnames[(given & 0xf00) >> 8]);
1763     }
1764 }
1765
1766 #define W_BIT 21
1767 #define I_BIT 22
1768 #define U_BIT 23
1769 #define P_BIT 24
1770
1771 #define WRITEBACK_BIT_SET   (given & (1 << W_BIT))
1772 #define IMMEDIATE_BIT_SET   (given & (1 << I_BIT))
1773 #define NEGATIVE_BIT_SET   ((given & (1 << U_BIT)) == 0)
1774 #define PRE_BIT_SET         (given & (1 << P_BIT))
1775
1776 /* Print one coprocessor instruction on INFO->STREAM.
1777    Return TRUE if the instuction matched, FALSE if this is not a
1778    recognised coprocessor instruction.  */
1779
1780 static bfd_boolean
1781 print_insn_coprocessor (bfd_vma pc,
1782                         struct disassemble_info *info,
1783                         long given,
1784                         bfd_boolean thumb)
1785 {
1786   const struct opcode32 *insn;
1787   void *stream = info->stream;
1788   fprintf_ftype func = info->fprintf_func;
1789   unsigned long mask;
1790   unsigned long value = 0;
1791   struct arm_private_data *private_data = info->private_data;
1792   unsigned long allowed_arches = private_data->features.coproc;
1793   int cond;
1794
1795   for (insn = coprocessor_opcodes; insn->assembler; insn++)
1796     {
1797       unsigned long u_reg = 16;
1798       bfd_boolean is_unpredictable = FALSE;
1799       signed long value_in_comment = 0;
1800       const char *c;
1801
1802       if (insn->arch == 0)
1803         switch (insn->value)
1804           {
1805           case SENTINEL_IWMMXT_START:
1806             if (info->mach != bfd_mach_arm_XScale
1807                 && info->mach != bfd_mach_arm_iWMMXt
1808                 && info->mach != bfd_mach_arm_iWMMXt2)
1809               do
1810                 insn++;
1811               while (insn->arch != 0 && insn->value != SENTINEL_IWMMXT_END);
1812             continue;
1813
1814           case SENTINEL_IWMMXT_END:
1815             continue;
1816
1817           case SENTINEL_GENERIC_START:
1818             allowed_arches = private_data->features.core;
1819             continue;
1820
1821           default:
1822             abort ();
1823           }
1824
1825       mask = insn->mask;
1826       value = insn->value;
1827       if (thumb)
1828         {
1829           /* The high 4 bits are 0xe for Arm conditional instructions, and
1830              0xe for arm unconditional instructions.  The rest of the
1831              encoding is the same.  */
1832           mask |= 0xf0000000;
1833           value |= 0xe0000000;
1834           if (ifthen_state)
1835             cond = IFTHEN_COND;
1836           else
1837             cond = 16;
1838         }
1839       else
1840         {
1841           /* Only match unconditional instuctions against unconditional
1842              patterns.  */
1843           if ((given & 0xf0000000) == 0xf0000000)
1844             {
1845               mask |= 0xf0000000;
1846               cond = 16;
1847             }
1848           else
1849             {
1850               cond = (given >> 28) & 0xf;
1851               if (cond == 0xe)
1852                 cond = 16;
1853             }
1854         }
1855
1856       if ((given & mask) != value)
1857         continue;
1858
1859       if ((insn->arch & allowed_arches) == 0)
1860         continue;
1861
1862       for (c = insn->assembler; *c; c++)
1863         {
1864           if (*c == '%')
1865             {
1866               switch (*++c)
1867                 {
1868                 case '%':
1869                   func (stream, "%%");
1870                   break;
1871
1872                 case 'A':
1873                   {
1874                     int rn = (given >> 16) & 0xf;
1875                     int offset = given & 0xff;
1876
1877                     func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
1878
1879                     if (PRE_BIT_SET || WRITEBACK_BIT_SET)
1880                       {
1881                         /* Not unindexed.  The offset is scaled.  */
1882                         offset = offset * 4;
1883                         if (NEGATIVE_BIT_SET)
1884                           offset = - offset;
1885                         if (rn != 15)
1886                           value_in_comment = offset;
1887                       }
1888
1889                     if (PRE_BIT_SET)
1890                       {
1891                         if (offset)
1892                           func (stream, ", #%d]%s",
1893                                 offset,
1894                                 WRITEBACK_BIT_SET ? "!" : "");
1895                         else
1896                           func (stream, "]");
1897                       }
1898                     else
1899                       {
1900                         func (stream, "]");
1901
1902                         if (WRITEBACK_BIT_SET)
1903                           {
1904                             if (offset)
1905                               func (stream, ", #%d", offset);
1906                           }
1907                         else
1908                           {
1909                             func (stream, ", {%d}", offset);
1910                             value_in_comment = offset;
1911                           }
1912                       }
1913                     if (rn == 15 && (PRE_BIT_SET || WRITEBACK_BIT_SET))
1914                       {
1915                         func (stream, "\t; ");
1916                         /* For unaligned PCs, apply off-by-alignment
1917                            correction.  */
1918                         info->print_address_func (offset + pc
1919                                                   + info->bytes_per_chunk * 2
1920                                                   - (pc & 3),
1921                                                   info);
1922                       }
1923                   }
1924                   break;
1925
1926                 case 'B':
1927                   {
1928                     int regno = ((given >> 12) & 0xf) | ((given >> (22 - 4)) & 0x10);
1929                     int offset = (given >> 1) & 0x3f;
1930
1931                     if (offset == 1)
1932                       func (stream, "{d%d}", regno);
1933                     else if (regno + offset > 32)
1934                       func (stream, "{d%d-<overflow reg d%d>}", regno, regno + offset - 1);
1935                     else
1936                       func (stream, "{d%d-d%d}", regno, regno + offset - 1);
1937                   }
1938                   break;
1939
1940                 case 'c':
1941                   func (stream, "%s", arm_conditional[cond]);
1942                   break;
1943
1944                 case 'I':
1945                   /* Print a Cirrus/DSP shift immediate.  */
1946                   /* Immediates are 7bit signed ints with bits 0..3 in
1947                      bits 0..3 of opcode and bits 4..6 in bits 5..7
1948                      of opcode.  */
1949                   {
1950                     int imm;
1951
1952                     imm = (given & 0xf) | ((given & 0xe0) >> 1);
1953
1954                     /* Is ``imm'' a negative number?  */
1955                     if (imm & 0x40)
1956                       imm |= (-1 << 7);
1957
1958                     func (stream, "%d", imm);
1959                   }
1960
1961                   break;
1962
1963                 case 'F':
1964                   switch (given & 0x00408000)
1965                     {
1966                     case 0:
1967                       func (stream, "4");
1968                       break;
1969                     case 0x8000:
1970                       func (stream, "1");
1971                       break;
1972                     case 0x00400000:
1973                       func (stream, "2");
1974                       break;
1975                     default:
1976                       func (stream, "3");
1977                     }
1978                   break;
1979
1980                 case 'P':
1981                   switch (given & 0x00080080)
1982                     {
1983                     case 0:
1984                       func (stream, "s");
1985                       break;
1986                     case 0x80:
1987                       func (stream, "d");
1988                       break;
1989                     case 0x00080000:
1990                       func (stream, "e");
1991                       break;
1992                     default:
1993                       func (stream, _("<illegal precision>"));
1994                       break;
1995                     }
1996                   break;
1997
1998                 case 'Q':
1999                   switch (given & 0x00408000)
2000                     {
2001                     case 0:
2002                       func (stream, "s");
2003                       break;
2004                     case 0x8000:
2005                       func (stream, "d");
2006                       break;
2007                     case 0x00400000:
2008                       func (stream, "e");
2009                       break;
2010                     default:
2011                       func (stream, "p");
2012                       break;
2013                     }
2014                   break;
2015
2016                 case 'R':
2017                   switch (given & 0x60)
2018                     {
2019                     case 0:
2020                       break;
2021                     case 0x20:
2022                       func (stream, "p");
2023                       break;
2024                     case 0x40:
2025                       func (stream, "m");
2026                       break;
2027                     default:
2028                       func (stream, "z");
2029                       break;
2030                     }
2031                   break;
2032
2033                 case '0': case '1': case '2': case '3': case '4':
2034                 case '5': case '6': case '7': case '8': case '9':
2035                   {
2036                     int width;
2037
2038                     c = arm_decode_bitfield (c, given, &value, &width);
2039
2040                     switch (*c)
2041                       {
2042                       case 'R':
2043                         if (value == 15)
2044                           is_unpredictable = TRUE;
2045                         /* Fall through.  */
2046                       case 'r':
2047                         if (c[1] == 'u')
2048                           {
2049                             /* Eat the 'u' character.  */
2050                             ++ c;
2051
2052                             if (u_reg == value)
2053                               is_unpredictable = TRUE;
2054                             u_reg = value;
2055                           }
2056                         func (stream, "%s", arm_regnames[value]);
2057                         break;
2058                       case 'D':
2059                         func (stream, "d%ld", value);
2060                         break;
2061                       case 'Q':
2062                         if (value & 1)
2063                           func (stream, "<illegal reg q%ld.5>", value >> 1);
2064                         else
2065                           func (stream, "q%ld", value >> 1);
2066                         break;
2067                       case 'd':
2068                         func (stream, "%ld", value);
2069                         value_in_comment = value;
2070                         break;
2071                       case 'k':
2072                         {
2073                           int from = (given & (1 << 7)) ? 32 : 16;
2074                           func (stream, "%ld", from - value);
2075                         }
2076                         break;
2077
2078                       case 'f':
2079                         if (value > 7)
2080                           func (stream, "#%s", arm_fp_const[value & 7]);
2081                         else
2082                           func (stream, "f%ld", value);
2083                         break;
2084
2085                       case 'w':
2086                         if (width == 2)
2087                           func (stream, "%s", iwmmxt_wwnames[value]);
2088                         else
2089                           func (stream, "%s", iwmmxt_wwssnames[value]);
2090                         break;
2091
2092                       case 'g':
2093                         func (stream, "%s", iwmmxt_regnames[value]);
2094                         break;
2095                       case 'G':
2096                         func (stream, "%s", iwmmxt_cregnames[value]);
2097                         break;
2098
2099                       case 'x':
2100                         func (stream, "0x%lx", (value & 0xffffffffUL));
2101                         break;
2102
2103                       case '`':
2104                         c++;
2105                         if (value == 0)
2106                           func (stream, "%c", *c);
2107                         break;
2108                       case '\'':
2109                         c++;
2110                         if (value == ((1ul << width) - 1))
2111                           func (stream, "%c", *c);
2112                         break;
2113                       case '?':
2114                         func (stream, "%c", c[(1 << width) - (int) value]);
2115                         c += 1 << width;
2116                         break;
2117                       default:
2118                         abort ();
2119                       }
2120                     break;
2121
2122                   case 'y':
2123                   case 'z':
2124                     {
2125                       int single = *c++ == 'y';
2126                       int regno;
2127
2128                       switch (*c)
2129                         {
2130                         case '4': /* Sm pair */
2131                         case '0': /* Sm, Dm */
2132                           regno = given & 0x0000000f;
2133                           if (single)
2134                             {
2135                               regno <<= 1;
2136                               regno += (given >> 5) & 1;
2137                             }
2138                           else
2139                             regno += ((given >> 5) & 1) << 4;
2140                           break;
2141
2142                         case '1': /* Sd, Dd */
2143                           regno = (given >> 12) & 0x0000000f;
2144                           if (single)
2145                             {
2146                               regno <<= 1;
2147                               regno += (given >> 22) & 1;
2148                             }
2149                           else
2150                             regno += ((given >> 22) & 1) << 4;
2151                           break;
2152
2153                         case '2': /* Sn, Dn */
2154                           regno = (given >> 16) & 0x0000000f;
2155                           if (single)
2156                             {
2157                               regno <<= 1;
2158                               regno += (given >> 7) & 1;
2159                             }
2160                           else
2161                             regno += ((given >> 7) & 1) << 4;
2162                           break;
2163
2164                         case '3': /* List */
2165                           func (stream, "{");
2166                           regno = (given >> 12) & 0x0000000f;
2167                           if (single)
2168                             {
2169                               regno <<= 1;
2170                               regno += (given >> 22) & 1;
2171                             }
2172                           else
2173                             regno += ((given >> 22) & 1) << 4;
2174                           break;
2175
2176                         default:
2177                           abort ();
2178                         }
2179
2180                       func (stream, "%c%d", single ? 's' : 'd', regno);
2181
2182                       if (*c == '3')
2183                         {
2184                           int count = given & 0xff;
2185
2186                           if (single == 0)
2187                             count >>= 1;
2188
2189                           if (--count)
2190                             {
2191                               func (stream, "-%c%d",
2192                                     single ? 's' : 'd',
2193                                     regno + count);
2194                             }
2195
2196                           func (stream, "}");
2197                         }
2198                       else if (*c == '4')
2199                         func (stream, ", %c%d", single ? 's' : 'd',
2200                               regno + 1);
2201                     }
2202                     break;
2203
2204                   case 'L':
2205                     switch (given & 0x00400100)
2206                       {
2207                       case 0x00000000: func (stream, "b"); break;
2208                       case 0x00400000: func (stream, "h"); break;
2209                       case 0x00000100: func (stream, "w"); break;
2210                       case 0x00400100: func (stream, "d"); break;
2211                       default:
2212                         break;
2213                       }
2214                     break;
2215
2216                   case 'Z':
2217                     {
2218                       /* given (20, 23) | given (0, 3) */
2219                       value = ((given >> 16) & 0xf0) | (given & 0xf);
2220                       func (stream, "%d", value);
2221                     }
2222                     break;
2223
2224                   case 'l':
2225                     /* This is like the 'A' operator, except that if
2226                        the width field "M" is zero, then the offset is
2227                        *not* multiplied by four.  */
2228                     {
2229                       int offset = given & 0xff;
2230                       int multiplier = (given & 0x00000100) ? 4 : 1;
2231
2232                       func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
2233
2234                       if (multiplier > 1)
2235                         {
2236                           value_in_comment = offset * multiplier;
2237                           if (NEGATIVE_BIT_SET)
2238                             value_in_comment = - value_in_comment;
2239                         }
2240
2241                       if (offset)
2242                         {
2243                           if (PRE_BIT_SET)
2244                             func (stream, ", #%s%d]%s",
2245                                   NEGATIVE_BIT_SET ? "-" : "",
2246                                   offset * multiplier,
2247                                   WRITEBACK_BIT_SET ? "!" : "");
2248                           else
2249                             func (stream, "], #%s%d",
2250                                   NEGATIVE_BIT_SET ? "-" : "",
2251                                   offset * multiplier);
2252                         }
2253                       else
2254                         func (stream, "]");
2255                     }
2256                     break;
2257
2258                   case 'r':
2259                     {
2260                       int imm4 = (given >> 4) & 0xf;
2261                       int puw_bits = ((given >> 22) & 6) | ((given >> W_BIT) & 1);
2262                       int ubit = ! NEGATIVE_BIT_SET;
2263                       const char *rm = arm_regnames [given & 0xf];
2264                       const char *rn = arm_regnames [(given >> 16) & 0xf];
2265
2266                       switch (puw_bits)
2267                         {
2268                         case 1:
2269                         case 3:
2270                           func (stream, "[%s], %c%s", rn, ubit ? '+' : '-', rm);
2271                           if (imm4)
2272                             func (stream, ", lsl #%d", imm4);
2273                           break;
2274
2275                         case 4:
2276                         case 5:
2277                         case 6:
2278                         case 7:
2279                           func (stream, "[%s, %c%s", rn, ubit ? '+' : '-', rm);
2280                           if (imm4 > 0)
2281                             func (stream, ", lsl #%d", imm4);
2282                           func (stream, "]");
2283                           if (puw_bits == 5 || puw_bits == 7)
2284                             func (stream, "!");
2285                           break;
2286
2287                         default:
2288                           func (stream, "INVALID");
2289                         }
2290                     }
2291                     break;
2292
2293                   case 'i':
2294                     {
2295                       long imm5;
2296                       imm5 = ((given & 0x100) >> 4) | (given & 0xf);
2297                       func (stream, "%ld", (imm5 == 0) ? 32 : imm5);
2298                     }
2299                     break;
2300
2301                   default:
2302                     abort ();
2303                   }
2304                 }
2305             }
2306           else
2307             func (stream, "%c", *c);
2308         }
2309
2310       if (value_in_comment > 32 || value_in_comment < -16)
2311         func (stream, "\t; 0x%lx", (value_in_comment & 0xffffffffUL));
2312
2313       if (is_unpredictable)
2314         func (stream, UNPREDICTABLE_INSTRUCTION);
2315
2316       return TRUE;
2317     }
2318   return FALSE;
2319 }
2320
2321 /* Decodes and prints ARM addressing modes.  Returns the offset
2322    used in the address, if any, if it is worthwhile printing the
2323    offset as a hexadecimal value in a comment at the end of the
2324    line of disassembly.  */
2325
2326 static signed long
2327 print_arm_address (bfd_vma pc, struct disassemble_info *info, long given)
2328 {
2329   void *stream = info->stream;
2330   fprintf_ftype func = info->fprintf_func;
2331   int offset = 0;
2332
2333   if (((given & 0x000f0000) == 0x000f0000)
2334       && ((given & 0x02000000) == 0))
2335     {
2336       offset = given & 0xfff;
2337
2338       func (stream, "[pc");
2339
2340       if (NEGATIVE_BIT_SET)
2341         offset = - offset;
2342
2343       if (PRE_BIT_SET)
2344         {
2345           /* Pre-indexed.  */
2346           func (stream, ", #%d]", offset);
2347
2348           offset += pc + 8;
2349
2350           /* Cope with the possibility of write-back
2351              being used.  Probably a very dangerous thing
2352              for the programmer to do, but who are we to
2353              argue ?  */
2354           if (WRITEBACK_BIT_SET)
2355             func (stream, "!");
2356         }
2357       else  /* Post indexed.  */
2358         {
2359           func (stream, "], #%d", offset);
2360
2361           /* Ie ignore the offset.  */
2362           offset = pc + 8;
2363         }
2364
2365       func (stream, "\t; ");
2366       info->print_address_func (offset, info);
2367       offset = 0;
2368     }
2369   else
2370     {
2371       func (stream, "[%s",
2372             arm_regnames[(given >> 16) & 0xf]);
2373
2374       if (PRE_BIT_SET)
2375         {
2376           if ((given & 0x02000000) == 0)
2377             {
2378               offset = given & 0xfff;
2379               if (offset)
2380                 func (stream, ", #%s%d",
2381                       NEGATIVE_BIT_SET ? "-" : "", offset);
2382             }
2383           else
2384             {
2385               func (stream, ", %s",
2386                     NEGATIVE_BIT_SET ? "-" : "");
2387               arm_decode_shift (given, func, stream, TRUE);
2388             }
2389
2390           func (stream, "]%s",
2391                 WRITEBACK_BIT_SET ? "!" : "");
2392         }
2393       else
2394         {
2395           if ((given & 0x02000000) == 0)
2396             {
2397               offset = given & 0xfff;
2398               if (offset)
2399                 func (stream, "], #%s%d",
2400                       NEGATIVE_BIT_SET ? "-" : "", offset);
2401               else
2402                 func (stream, "]");
2403             }
2404           else
2405             {
2406               func (stream, "], %s",
2407                     NEGATIVE_BIT_SET ? "-" : "");
2408               arm_decode_shift (given, func, stream, TRUE);
2409             }
2410         }
2411     }
2412
2413   return (signed long) offset;
2414 }
2415
2416 /* Print one neon instruction on INFO->STREAM.
2417    Return TRUE if the instuction matched, FALSE if this is not a
2418    recognised neon instruction.  */
2419
2420 static bfd_boolean
2421 print_insn_neon (struct disassemble_info *info, long given, bfd_boolean thumb)
2422 {
2423   const struct opcode32 *insn;
2424   void *stream = info->stream;
2425   fprintf_ftype func = info->fprintf_func;
2426
2427   if (thumb)
2428     {
2429       if ((given & 0xef000000) == 0xef000000)
2430         {
2431           /* Move bit 28 to bit 24 to translate Thumb2 to ARM encoding.  */
2432           unsigned long bit28 = given & (1 << 28);
2433
2434           given &= 0x00ffffff;
2435           if (bit28)
2436             given |= 0xf3000000;
2437           else
2438             given |= 0xf2000000;
2439         }
2440       else if ((given & 0xff000000) == 0xf9000000)
2441         given ^= 0xf9000000 ^ 0xf4000000;
2442       else
2443         return FALSE;
2444     }
2445
2446   for (insn = neon_opcodes; insn->assembler; insn++)
2447     {
2448       if ((given & insn->mask) == insn->value)
2449         {
2450           signed long value_in_comment = 0;
2451           const char *c;
2452
2453           for (c = insn->assembler; *c; c++)
2454             {
2455               if (*c == '%')
2456                 {
2457                   switch (*++c)
2458                     {
2459                     case '%':
2460                       func (stream, "%%");
2461                       break;
2462
2463                     case 'c':
2464                       if (thumb && ifthen_state)
2465                         func (stream, "%s", arm_conditional[IFTHEN_COND]);
2466                       break;
2467
2468                     case 'A':
2469                       {
2470                         static const unsigned char enc[16] =
2471                         {
2472                           0x4, 0x14, /* st4 0,1 */
2473                           0x4, /* st1 2 */
2474                           0x4, /* st2 3 */
2475                           0x3, /* st3 4 */
2476                           0x13, /* st3 5 */
2477                           0x3, /* st1 6 */
2478                           0x1, /* st1 7 */
2479                           0x2, /* st2 8 */
2480                           0x12, /* st2 9 */
2481                           0x2, /* st1 10 */
2482                           0, 0, 0, 0, 0
2483                         };
2484                         int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2485                         int rn = ((given >> 16) & 0xf);
2486                         int rm = ((given >> 0) & 0xf);
2487                         int align = ((given >> 4) & 0x3);
2488                         int type = ((given >> 8) & 0xf);
2489                         int n = enc[type] & 0xf;
2490                         int stride = (enc[type] >> 4) + 1;
2491                         int ix;
2492
2493                         func (stream, "{");
2494                         if (stride > 1)
2495                           for (ix = 0; ix != n; ix++)
2496                             func (stream, "%sd%d", ix ? "," : "", rd + ix * stride);
2497                         else if (n == 1)
2498                           func (stream, "d%d", rd);
2499                         else
2500                           func (stream, "d%d-d%d", rd, rd + n - 1);
2501                         func (stream, "}, [%s", arm_regnames[rn]);
2502                         if (align)
2503                           func (stream, " :%d", 32 << align);
2504                         func (stream, "]");
2505                         if (rm == 0xd)
2506                           func (stream, "!");
2507                         else if (rm != 0xf)
2508                           func (stream, ", %s", arm_regnames[rm]);
2509                       }
2510                       break;
2511
2512                     case 'B':
2513                       {
2514                         int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2515                         int rn = ((given >> 16) & 0xf);
2516                         int rm = ((given >> 0) & 0xf);
2517                         int idx_align = ((given >> 4) & 0xf);
2518                         int align = 0;
2519                         int size = ((given >> 10) & 0x3);
2520                         int idx = idx_align >> (size + 1);
2521                         int length = ((given >> 8) & 3) + 1;
2522                         int stride = 1;
2523                         int i;
2524
2525                         if (length > 1 && size > 0)
2526                           stride = (idx_align & (1 << size)) ? 2 : 1;
2527
2528                         switch (length)
2529                           {
2530                           case 1:
2531                             {
2532                               int amask = (1 << size) - 1;
2533                               if ((idx_align & (1 << size)) != 0)
2534                                 return FALSE;
2535                               if (size > 0)
2536                                 {
2537                                   if ((idx_align & amask) == amask)
2538                                     align = 8 << size;
2539                                   else if ((idx_align & amask) != 0)
2540                                     return FALSE;
2541                                 }
2542                               }
2543                             break;
2544
2545                           case 2:
2546                             if (size == 2 && (idx_align & 2) != 0)
2547                               return FALSE;
2548                             align = (idx_align & 1) ? 16 << size : 0;
2549                             break;
2550
2551                           case 3:
2552                             if ((size == 2 && (idx_align & 3) != 0)
2553                                 || (idx_align & 1) != 0)
2554                               return FALSE;
2555                             break;
2556
2557                           case 4:
2558                             if (size == 2)
2559                               {
2560                                 if ((idx_align & 3) == 3)
2561                                   return FALSE;
2562                                 align = (idx_align & 3) * 64;
2563                               }
2564                             else
2565                               align = (idx_align & 1) ? 32 << size : 0;
2566                             break;
2567
2568                           default:
2569                             abort ();
2570                           }
2571
2572                         func (stream, "{");
2573                         for (i = 0; i < length; i++)
2574                           func (stream, "%sd%d[%d]", (i == 0) ? "" : ",",
2575                             rd + i * stride, idx);
2576                         func (stream, "}, [%s", arm_regnames[rn]);
2577                         if (align)
2578                           func (stream, " :%d", align);
2579                         func (stream, "]");
2580                         if (rm == 0xd)
2581                           func (stream, "!");
2582                         else if (rm != 0xf)
2583                           func (stream, ", %s", arm_regnames[rm]);
2584                       }
2585                       break;
2586
2587                     case 'C':
2588                       {
2589                         int rd = ((given >> 12) & 0xf) | (((given >> 22) & 1) << 4);
2590                         int rn = ((given >> 16) & 0xf);
2591                         int rm = ((given >> 0) & 0xf);
2592                         int align = ((given >> 4) & 0x1);
2593                         int size = ((given >> 6) & 0x3);
2594                         int type = ((given >> 8) & 0x3);
2595                         int n = type + 1;
2596                         int stride = ((given >> 5) & 0x1);
2597                         int ix;
2598
2599                         if (stride && (n == 1))
2600                           n++;
2601                         else
2602                           stride++;
2603
2604                         func (stream, "{");
2605                         if (stride > 1)
2606                           for (ix = 0; ix != n; ix++)
2607                             func (stream, "%sd%d[]", ix ? "," : "", rd + ix * stride);
2608                         else if (n == 1)
2609                           func (stream, "d%d[]", rd);
2610                         else
2611                           func (stream, "d%d[]-d%d[]", rd, rd + n - 1);
2612                         func (stream, "}, [%s", arm_regnames[rn]);
2613                         if (align)
2614                           {
2615                             align = (8 * (type + 1)) << size;
2616                             if (type == 3)
2617                               align = (size > 1) ? align >> 1 : align;
2618                             if (type == 2 || (type == 0 && !size))
2619                               func (stream, " :<bad align %d>", align);
2620                             else
2621                               func (stream, " :%d", align);
2622                           }
2623                         func (stream, "]");
2624                         if (rm == 0xd)
2625                           func (stream, "!");
2626                         else if (rm != 0xf)
2627                           func (stream, ", %s", arm_regnames[rm]);
2628                       }
2629                       break;
2630
2631                     case 'D':
2632                       {
2633                         int raw_reg = (given & 0xf) | ((given >> 1) & 0x10);
2634                         int size = (given >> 20) & 3;
2635                         int reg = raw_reg & ((4 << size) - 1);
2636                         int ix = raw_reg >> size >> 2;
2637
2638                         func (stream, "d%d[%d]", reg, ix);
2639                       }
2640                       break;
2641
2642                     case 'E':
2643                       /* Neon encoded constant for mov, mvn, vorr, vbic.  */
2644                       {
2645                         int bits = 0;
2646                         int cmode = (given >> 8) & 0xf;
2647                         int op = (given >> 5) & 0x1;
2648                         unsigned long value = 0, hival = 0;
2649                         unsigned shift;
2650                         int size = 0;
2651                         int isfloat = 0;
2652
2653                         bits |= ((given >> 24) & 1) << 7;
2654                         bits |= ((given >> 16) & 7) << 4;
2655                         bits |= ((given >> 0) & 15) << 0;
2656
2657                         if (cmode < 8)
2658                           {
2659                             shift = (cmode >> 1) & 3;
2660                             value = (unsigned long) bits << (8 * shift);
2661                             size = 32;
2662                           }
2663                         else if (cmode < 12)
2664                           {
2665                             shift = (cmode >> 1) & 1;
2666                             value = (unsigned long) bits << (8 * shift);
2667                             size = 16;
2668                           }
2669                         else if (cmode < 14)
2670                           {
2671                             shift = (cmode & 1) + 1;
2672                             value = (unsigned long) bits << (8 * shift);
2673                             value |= (1ul << (8 * shift)) - 1;
2674                             size = 32;
2675                           }
2676                         else if (cmode == 14)
2677                           {
2678                             if (op)
2679                               {
2680                                 /* Bit replication into bytes.  */
2681                                 int ix;
2682                                 unsigned long mask;
2683
2684                                 value = 0;
2685                                 hival = 0;
2686                                 for (ix = 7; ix >= 0; ix--)
2687                                   {
2688                                     mask = ((bits >> ix) & 1) ? 0xff : 0;
2689                                     if (ix <= 3)
2690                                       value = (value << 8) | mask;
2691                                     else
2692                                       hival = (hival << 8) | mask;
2693                                   }
2694                                 size = 64;
2695                               }
2696                             else
2697                               {
2698                                 /* Byte replication.  */
2699                                 value = (unsigned long) bits;
2700                                 size = 8;
2701                               }
2702                           }
2703                         else if (!op)
2704                           {
2705                             /* Floating point encoding.  */
2706                             int tmp;
2707
2708                             value = (unsigned long)  (bits & 0x7f) << 19;
2709                             value |= (unsigned long) (bits & 0x80) << 24;
2710                             tmp = bits & 0x40 ? 0x3c : 0x40;
2711                             value |= (unsigned long) tmp << 24;
2712                             size = 32;
2713                             isfloat = 1;
2714                           }
2715                         else
2716                           {
2717                             func (stream, "<illegal constant %.8x:%x:%x>",
2718                                   bits, cmode, op);
2719                             size = 32;
2720                             break;
2721                           }
2722                         switch (size)
2723                           {
2724                           case 8:
2725                             func (stream, "#%ld\t; 0x%.2lx", value, value);
2726                             break;
2727
2728                           case 16:
2729                             func (stream, "#%ld\t; 0x%.4lx", value, value);
2730                             break;
2731
2732                           case 32:
2733                             if (isfloat)
2734                               {
2735                                 unsigned char valbytes[4];
2736                                 double fvalue;
2737
2738                                 /* Do this a byte at a time so we don't have to
2739                                    worry about the host's endianness.  */
2740                                 valbytes[0] = value & 0xff;
2741                                 valbytes[1] = (value >> 8) & 0xff;
2742                                 valbytes[2] = (value >> 16) & 0xff;
2743                                 valbytes[3] = (value >> 24) & 0xff;
2744
2745                                 floatformat_to_double
2746                                   (& floatformat_ieee_single_little, valbytes,
2747                                   & fvalue);
2748
2749                                 func (stream, "#%.7g\t; 0x%.8lx", fvalue,
2750                                       value);
2751                               }
2752                             else
2753                               func (stream, "#%ld\t; 0x%.8lx",
2754                                     (long) (((value & 0x80000000L) != 0)
2755                                             ? value | ~0xffffffffL : value),
2756                                     value);
2757                             break;
2758
2759                           case 64:
2760                             func (stream, "#0x%.8lx%.8lx", hival, value);
2761                             break;
2762
2763                           default:
2764                             abort ();
2765                           }
2766                       }
2767                       break;
2768
2769                     case 'F':
2770                       {
2771                         int regno = ((given >> 16) & 0xf) | ((given >> (7 - 4)) & 0x10);
2772                         int num = (given >> 8) & 0x3;
2773
2774                         if (!num)
2775                           func (stream, "{d%d}", regno);
2776                         else if (num + regno >= 32)
2777                           func (stream, "{d%d-<overflow reg d%d}", regno, regno + num);
2778                         else
2779                           func (stream, "{d%d-d%d}", regno, regno + num);
2780                       }
2781                       break;
2782
2783
2784                     case '0': case '1': case '2': case '3': case '4':
2785                     case '5': case '6': case '7': case '8': case '9':
2786                       {
2787                         int width;
2788                         unsigned long value;
2789
2790                         c = arm_decode_bitfield (c, given, &value, &width);
2791
2792                         switch (*c)
2793                           {
2794                           case 'r':
2795                             func (stream, "%s", arm_regnames[value]);
2796                             break;
2797                           case 'd':
2798                             func (stream, "%ld", value);
2799                             value_in_comment = value;
2800                             break;
2801                           case 'e':
2802                             func (stream, "%ld", (1ul << width) - value);
2803                             break;
2804
2805                           case 'S':
2806                           case 'T':
2807                           case 'U':
2808                             /* Various width encodings.  */
2809                             {
2810                               int base = 8 << (*c - 'S'); /* 8,16 or 32 */
2811                               int limit;
2812                               unsigned low, high;
2813
2814                               c++;
2815                               if (*c >= '0' && *c <= '9')
2816                                 limit = *c - '0';
2817                               else if (*c >= 'a' && *c <= 'f')
2818                                 limit = *c - 'a' + 10;
2819                               else
2820                                 abort ();
2821                               low = limit >> 2;
2822                               high = limit & 3;
2823
2824                               if (value < low || value > high)
2825                                 func (stream, "<illegal width %d>", base << value);
2826                               else
2827                                 func (stream, "%d", base << value);
2828                             }
2829                             break;
2830                           case 'R':
2831                             if (given & (1 << 6))
2832                               goto Q;
2833                             /* FALLTHROUGH */
2834                           case 'D':
2835                             func (stream, "d%ld", value);
2836                             break;
2837                           case 'Q':
2838                           Q:
2839                             if (value & 1)
2840                               func (stream, "<illegal reg q%ld.5>", value >> 1);
2841                             else
2842                               func (stream, "q%ld", value >> 1);
2843                             break;
2844
2845                           case '`':
2846                             c++;
2847                             if (value == 0)
2848                               func (stream, "%c", *c);
2849                             break;
2850                           case '\'':
2851                             c++;
2852                             if (value == ((1ul << width) - 1))
2853                               func (stream, "%c", *c);
2854                             break;
2855                           case '?':
2856                             func (stream, "%c", c[(1 << width) - (int) value]);
2857                             c += 1 << width;
2858                             break;
2859                           default:
2860                             abort ();
2861                           }
2862                         break;
2863
2864                       default:
2865                         abort ();
2866                       }
2867                     }
2868                 }
2869               else
2870                 func (stream, "%c", *c);
2871             }
2872
2873           if (value_in_comment > 32 || value_in_comment < -16)
2874             func (stream, "\t; 0x%lx", value_in_comment);
2875
2876           return TRUE;
2877         }
2878     }
2879   return FALSE;
2880 }
2881
2882 /* Return the name of a v7A special register.  */
2883
2884 static const char *
2885 banked_regname (unsigned reg)
2886 {
2887   switch (reg)
2888     {
2889       case 15: return "CPSR";
2890       case 32: return "R8_usr";
2891       case 33: return "R9_usr";
2892       case 34: return "R10_usr";
2893       case 35: return "R11_usr";
2894       case 36: return "R12_usr";
2895       case 37: return "SP_usr";
2896       case 38: return "LR_usr";
2897       case 40: return "R8_fiq";
2898       case 41: return "R9_fiq";
2899       case 42: return "R10_fiq";
2900       case 43: return "R11_fiq";
2901       case 44: return "R12_fiq";
2902       case 45: return "SP_fiq";
2903       case 46: return "LR_fiq";
2904       case 48: return "LR_irq";
2905       case 49: return "SP_irq";
2906       case 50: return "LR_svc";
2907       case 51: return "SP_svc";
2908       case 52: return "LR_abt";
2909       case 53: return "SP_abt";
2910       case 54: return "LR_und";
2911       case 55: return "SP_und";
2912       case 60: return "LR_mon";
2913       case 61: return "SP_mon";
2914       case 62: return "ELR_hyp";
2915       case 63: return "SP_hyp";
2916       case 79: return "SPSR";
2917       case 110: return "SPSR_fiq";
2918       case 112: return "SPSR_irq";
2919       case 114: return "SPSR_svc";
2920       case 116: return "SPSR_abt";
2921       case 118: return "SPSR_und";
2922       case 124: return "SPSR_mon";
2923       case 126: return "SPSR_hyp";
2924       default: return NULL;
2925     }
2926 }
2927
2928 /* Print one ARM instruction from PC on INFO->STREAM.  */
2929
2930 static void
2931 print_insn_arm (bfd_vma pc, struct disassemble_info *info, long given)
2932 {
2933   const struct opcode32 *insn;
2934   void *stream = info->stream;
2935   fprintf_ftype func = info->fprintf_func;
2936   struct arm_private_data *private_data = info->private_data;
2937
2938   if (print_insn_coprocessor (pc, info, given, FALSE))
2939     return;
2940
2941   if (print_insn_neon (info, given, FALSE))
2942     return;
2943
2944   for (insn = arm_opcodes; insn->assembler; insn++)
2945     {
2946       if ((given & insn->mask) != insn->value)
2947         continue;
2948
2949       if ((insn->arch & private_data->features.core) == 0)
2950         continue;
2951
2952       /* Special case: an instruction with all bits set in the condition field
2953          (0xFnnn_nnnn) is only matched if all those bits are set in insn->mask,
2954          or by the catchall at the end of the table.  */
2955       if ((given & 0xF0000000) != 0xF0000000
2956           || (insn->mask & 0xF0000000) == 0xF0000000
2957           || (insn->mask == 0 && insn->value == 0))
2958         {
2959           unsigned long u_reg = 16;
2960           unsigned long U_reg = 16;
2961           bfd_boolean is_unpredictable = FALSE;
2962           signed long value_in_comment = 0;
2963           const char *c;
2964
2965           for (c = insn->assembler; *c; c++)
2966             {
2967               if (*c == '%')
2968                 {
2969                   bfd_boolean allow_unpredictable = FALSE;
2970
2971                   switch (*++c)
2972                     {
2973                     case '%':
2974                       func (stream, "%%");
2975                       break;
2976
2977                     case 'a':
2978                       value_in_comment = print_arm_address (pc, info, given);
2979                       break;
2980
2981                     case 'P':
2982                       /* Set P address bit and use normal address
2983                          printing routine.  */
2984                       value_in_comment = print_arm_address (pc, info, given | (1 << P_BIT));
2985                       break;
2986
2987                     case 'S':
2988                       allow_unpredictable = TRUE;
2989                     case 's':
2990                       if ((given & 0x004f0000) == 0x004f0000)
2991                         {
2992                           /* PC relative with immediate offset.  */
2993                           int offset = ((given & 0xf00) >> 4) | (given & 0xf);
2994
2995                           if (NEGATIVE_BIT_SET)
2996                             offset = - offset;
2997
2998                           if (PRE_BIT_SET)
2999                             {
3000                               if (offset)
3001                                 func (stream, "[pc, #%d]\t; ", offset);
3002                               else
3003                                 func (stream, "[pc]\t; ");
3004                               info->print_address_func (offset + pc + 8, info);
3005                             }
3006                           else
3007                             {
3008                               func (stream, "[pc], #%d", offset);
3009                               if (! allow_unpredictable)
3010                                 is_unpredictable = TRUE;
3011                             }
3012                         }
3013                       else
3014                         {
3015                           int offset = ((given & 0xf00) >> 4) | (given & 0xf);
3016
3017                           if (NEGATIVE_BIT_SET)
3018                             offset = - offset;
3019
3020                           func (stream, "[%s",
3021                                 arm_regnames[(given >> 16) & 0xf]);
3022
3023                           if (PRE_BIT_SET)
3024                             {
3025                               if (IMMEDIATE_BIT_SET)
3026                                 {
3027                                   if (WRITEBACK_BIT_SET)
3028                                     /* Immediate Pre-indexed.  */
3029                                     /* PR 10924: Offset must be printed, even if it is zero.  */
3030                                     func (stream, ", #%d", offset);
3031                                   else if (offset)
3032                                     /* Immediate Offset: printing zero offset is optional.  */
3033                                     func (stream, ", #%d", offset);
3034
3035                                   value_in_comment = offset;
3036                                 }
3037                               else
3038                                 {
3039                                   /* Register Offset or Register Pre-Indexed.  */
3040                                   func (stream, ", %s%s",
3041                                         NEGATIVE_BIT_SET ? "-" : "",
3042                                         arm_regnames[given & 0xf]);
3043
3044                                   /* Writing back to the register that is the source/
3045                                      destination of the load/store is unpredictable.  */
3046                                   if (! allow_unpredictable
3047                                       && WRITEBACK_BIT_SET
3048                                       && ((given & 0xf) == ((given >> 12) & 0xf)))
3049                                     is_unpredictable = TRUE;
3050                                 }
3051
3052                               func (stream, "]%s",
3053                                     WRITEBACK_BIT_SET ? "!" : "");
3054                             }
3055                           else
3056                             {
3057                               if (IMMEDIATE_BIT_SET)
3058                                 {
3059                                   /* Immediate Post-indexed.  */
3060                                   /* PR 10924: Offset must be printed, even if it is zero.  */
3061                                   func (stream, "], #%d", offset);
3062                                   value_in_comment = offset;
3063                                 }
3064                               else
3065                                 {
3066                                   /* Register Post-indexed.  */
3067                                   func (stream, "], %s%s",
3068                                         NEGATIVE_BIT_SET ? "-" : "",
3069                                         arm_regnames[given & 0xf]);
3070
3071                                   /* Writing back to the register that is the source/
3072                                      destination of the load/store is unpredictable.  */
3073                                   if (! allow_unpredictable
3074                                       && (given & 0xf) == ((given >> 12) & 0xf))
3075                                     is_unpredictable = TRUE;
3076                                 }
3077
3078                               if (! allow_unpredictable)
3079                                 {
3080                                   /* Writeback is automatically implied by post- addressing.
3081                                      Setting the W bit is unnecessary and ARM specify it as
3082                                      being unpredictable.  */
3083                                   if (WRITEBACK_BIT_SET
3084                                       /* Specifying the PC register as the post-indexed
3085                                          registers is also unpredictable.  */
3086                                       || (! IMMEDIATE_BIT_SET && ((given & 0xf) == 0xf)))
3087                                     is_unpredictable = TRUE;
3088                                 }
3089                             }
3090                         }
3091                       break;
3092
3093                     case 'b':
3094                       {
3095                         int disp = (((given & 0xffffff) ^ 0x800000) - 0x800000);
3096                         info->print_address_func (disp * 4 + pc + 8, info);
3097                       }
3098                       break;
3099
3100                     case 'c':
3101                       if (((given >> 28) & 0xf) != 0xe)
3102                         func (stream, "%s",
3103                               arm_conditional [(given >> 28) & 0xf]);
3104                       break;
3105
3106                     case 'm':
3107                       {
3108                         int started = 0;
3109                         int reg;
3110
3111                         func (stream, "{");
3112                         for (reg = 0; reg < 16; reg++)
3113                           if ((given & (1 << reg)) != 0)
3114                             {
3115                               if (started)
3116                                 func (stream, ", ");
3117                               started = 1;
3118                               func (stream, "%s", arm_regnames[reg]);
3119                             }
3120                         func (stream, "}");
3121                         if (! started)
3122                           is_unpredictable = TRUE;
3123                       }
3124                       break;
3125
3126                     case 'q':
3127                       arm_decode_shift (given, func, stream, FALSE);
3128                       break;
3129
3130                     case 'o':
3131                       if ((given & 0x02000000) != 0)
3132                         {
3133                           int rotate = (given & 0xf00) >> 7;
3134                           int immed = (given & 0xff);
3135
3136                           immed = (((immed << (32 - rotate))
3137                                     | (immed >> rotate)) & 0xffffffff);
3138                           func (stream, "#%d", immed);
3139                           value_in_comment = immed;
3140                         }
3141                       else
3142                         arm_decode_shift (given, func, stream, TRUE);
3143                       break;
3144
3145                     case 'p':
3146                       if ((given & 0x0000f000) == 0x0000f000)
3147                         {
3148                           /* The p-variants of tst/cmp/cmn/teq are the pre-V6
3149                              mechanism for setting PSR flag bits.  They are
3150                              obsolete in V6 onwards.  */
3151                           if ((private_data->features.core & ARM_EXT_V6) == 0)
3152                             func (stream, "p");
3153                         }
3154                       break;
3155
3156                     case 't':
3157                       if ((given & 0x01200000) == 0x00200000)
3158                         func (stream, "t");
3159                       break;
3160
3161                     case 'A':
3162                       {
3163                         int offset = given & 0xff;
3164
3165                         value_in_comment = offset * 4;
3166                         if (NEGATIVE_BIT_SET)
3167                           value_in_comment = - value_in_comment;
3168
3169                         func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
3170
3171                         if (PRE_BIT_SET)
3172                           {
3173                             if (offset)
3174                               func (stream, ", #%d]%s",
3175                                     value_in_comment,
3176                                     WRITEBACK_BIT_SET ? "!" : "");
3177                             else
3178                               func (stream, "]");
3179                           }
3180                         else
3181                           {
3182                             func (stream, "]");
3183
3184                             if (WRITEBACK_BIT_SET)
3185                               {
3186                                 if (offset)
3187                                   func (stream, ", #%d", value_in_comment);
3188                               }
3189                             else
3190                               {
3191                                 func (stream, ", {%d}", offset);
3192                                 value_in_comment = offset;
3193                               }
3194                           }
3195                       }
3196                       break;
3197
3198                     case 'B':
3199                       /* Print ARM V5 BLX(1) address: pc+25 bits.  */
3200                       {
3201                         bfd_vma address;
3202                         bfd_vma offset = 0;
3203
3204                         if (! NEGATIVE_BIT_SET)
3205                           /* Is signed, hi bits should be ones.  */
3206                           offset = (-1) ^ 0x00ffffff;
3207
3208                         /* Offset is (SignExtend(offset field)<<2).  */
3209                         offset += given & 0x00ffffff;
3210                         offset <<= 2;
3211                         address = offset + pc + 8;
3212
3213                         if (given & 0x01000000)
3214                           /* H bit allows addressing to 2-byte boundaries.  */
3215                           address += 2;
3216
3217                         info->print_address_func (address, info);
3218                       }
3219                       break;
3220
3221                     case 'C':
3222                       if ((given & 0x02000200) == 0x200)
3223                         {
3224                           const char * name;
3225                           unsigned sysm = (given & 0x004f0000) >> 16;
3226
3227                           sysm |= (given & 0x300) >> 4;
3228                           name = banked_regname (sysm);
3229
3230                           if (name != NULL)
3231                             func (stream, "%s", name);
3232                           else
3233                             func (stream, "(UNDEF: %lu)", sysm);
3234                         }
3235                       else
3236                         {
3237                           func (stream, "%cPSR_",
3238                                 (given & 0x00400000) ? 'S' : 'C');
3239                           if (given & 0x80000)
3240                             func (stream, "f");
3241                           if (given & 0x40000)
3242                             func (stream, "s");
3243                           if (given & 0x20000)
3244                             func (stream, "x");
3245                           if (given & 0x10000)
3246                             func (stream, "c");
3247                         }
3248                       break;
3249
3250                     case 'U':
3251                       if ((given & 0xf0) == 0x60)
3252                         {
3253                           switch (given & 0xf)
3254                             {
3255                             case 0xf: func (stream, "sy"); break;
3256                             default:
3257                               func (stream, "#%d", (int) given & 0xf);
3258                               break;
3259                             }
3260                         }
3261                       else
3262                         {
3263                           switch (given & 0xf)
3264                             {
3265                             case 0xf: func (stream, "sy"); break;
3266                             case 0x7: func (stream, "un"); break;
3267                             case 0xe: func (stream, "st"); break;
3268                             case 0x6: func (stream, "unst"); break;
3269                             case 0xb: func (stream, "ish"); break;
3270                             case 0xa: func (stream, "ishst"); break;
3271                             case 0x3: func (stream, "osh"); break;
3272                             case 0x2: func (stream, "oshst"); break;
3273                             default:
3274                               func (stream, "#%d", (int) given & 0xf);
3275                               break;
3276                             }
3277                         }
3278                       break;
3279
3280                     case '0': case '1': case '2': case '3': case '4':
3281                     case '5': case '6': case '7': case '8': case '9':
3282                       {
3283                         int width;
3284                         unsigned long value;
3285
3286                         c = arm_decode_bitfield (c, given, &value, &width);
3287
3288                         switch (*c)
3289                           {
3290                           case 'R':
3291                             if (value == 15)
3292                               is_unpredictable = TRUE;
3293                             /* Fall through.  */
3294                           case 'r':
3295                             if (c[1] == 'u')
3296                               {
3297                                 /* Eat the 'u' character.  */
3298                                 ++ c;
3299
3300                                 if (u_reg == value)
3301                                   is_unpredictable = TRUE;
3302                                 u_reg = value;
3303                               }
3304                             if (c[1] == 'U')
3305                               {
3306                                 /* Eat the 'U' character.  */
3307                                 ++ c;
3308
3309                                 if (U_reg == value)
3310                                   is_unpredictable = TRUE;
3311                                 U_reg = value;
3312                               }
3313                             func (stream, "%s", arm_regnames[value]);
3314                             break;
3315                           case 'd':
3316                             func (stream, "%ld", value);
3317                             value_in_comment = value;
3318                             break;
3319                           case 'b':
3320                             func (stream, "%ld", value * 8);
3321                             value_in_comment = value * 8;
3322                             break;
3323                           case 'W':
3324                             func (stream, "%ld", value + 1);
3325                             value_in_comment = value + 1;
3326                             break;
3327                           case 'x':
3328                             func (stream, "0x%08lx", value);
3329
3330                             /* Some SWI instructions have special
3331                                meanings.  */
3332                             if ((given & 0x0fffffff) == 0x0FF00000)
3333                               func (stream, "\t; IMB");
3334                             else if ((given & 0x0fffffff) == 0x0FF00001)
3335                               func (stream, "\t; IMBRange");
3336                             break;
3337                           case 'X':
3338                             func (stream, "%01lx", value & 0xf);
3339                             value_in_comment = value;
3340                             break;
3341                           case '`':
3342                             c++;
3343                             if (value == 0)
3344                               func (stream, "%c", *c);
3345                             break;
3346                           case '\'':
3347                             c++;
3348                             if (value == ((1ul << width) - 1))
3349                               func (stream, "%c", *c);
3350                             break;
3351                           case '?':
3352                             func (stream, "%c", c[(1 << width) - (int) value]);
3353                             c += 1 << width;
3354                             break;
3355                           default:
3356                             abort ();
3357                           }
3358                         break;
3359
3360                       case 'e':
3361                         {
3362                           int imm;
3363
3364                           imm = (given & 0xf) | ((given & 0xfff00) >> 4);
3365                           func (stream, "%d", imm);
3366                           value_in_comment = imm;
3367                         }
3368                         break;
3369
3370                       case 'E':
3371                         /* LSB and WIDTH fields of BFI or BFC.  The machine-
3372                            language instruction encodes LSB and MSB.  */
3373                         {
3374                           long msb = (given & 0x001f0000) >> 16;
3375                           long lsb = (given & 0x00000f80) >> 7;
3376                           long w = msb - lsb + 1;
3377
3378                           if (w > 0)
3379                             func (stream, "#%lu, #%lu", lsb, w);
3380                           else
3381                             func (stream, "(invalid: %lu:%lu)", lsb, msb);
3382                         }
3383                         break;
3384
3385                       case 'R':
3386                         /* Get the PSR/banked register name.  */
3387                         {
3388                           const char * name;
3389                           unsigned sysm = (given & 0x004f0000) >> 16;
3390
3391                           sysm |= (given & 0x300) >> 4;
3392                           name = banked_regname (sysm);
3393
3394                           if (name != NULL)
3395                             func (stream, "%s", name);
3396                           else
3397                             func (stream, "(UNDEF: %lu)", sysm);
3398                         }
3399                         break;
3400
3401                       case 'V':
3402                         /* 16-bit unsigned immediate from a MOVT or MOVW
3403                            instruction, encoded in bits 0:11 and 15:19.  */
3404                         {
3405                           long hi = (given & 0x000f0000) >> 4;
3406                           long lo = (given & 0x00000fff);
3407                           long imm16 = hi | lo;
3408
3409                           func (stream, "#%lu", imm16);
3410                           value_in_comment = imm16;
3411                         }
3412                         break;
3413
3414                       default:
3415                         abort ();
3416                       }
3417                     }
3418                 }
3419               else
3420                 func (stream, "%c", *c);
3421             }
3422
3423           if (value_in_comment > 32 || value_in_comment < -16)
3424             func (stream, "\t; 0x%lx", (value_in_comment & 0xffffffffUL));
3425
3426           if (is_unpredictable)
3427             func (stream, UNPREDICTABLE_INSTRUCTION);
3428
3429           return;
3430         }
3431     }
3432   abort ();
3433 }
3434
3435 /* Print one 16-bit Thumb instruction from PC on INFO->STREAM.  */
3436
3437 static void
3438 print_insn_thumb16 (bfd_vma pc, struct disassemble_info *info, long given)
3439 {
3440   const struct opcode16 *insn;
3441   void *stream = info->stream;
3442   fprintf_ftype func = info->fprintf_func;
3443
3444   for (insn = thumb_opcodes; insn->assembler; insn++)
3445     if ((given & insn->mask) == insn->value)
3446       {
3447         signed long value_in_comment = 0;
3448         const char *c = insn->assembler;
3449
3450         for (; *c; c++)
3451           {
3452             int domaskpc = 0;
3453             int domasklr = 0;
3454
3455             if (*c != '%')
3456               {
3457                 func (stream, "%c", *c);
3458                 continue;
3459               }
3460
3461             switch (*++c)
3462               {
3463               case '%':
3464                 func (stream, "%%");
3465                 break;
3466
3467               case 'c':
3468                 if (ifthen_state)
3469                   func (stream, "%s", arm_conditional[IFTHEN_COND]);
3470                 break;
3471
3472               case 'C':
3473                 if (ifthen_state)
3474                   func (stream, "%s", arm_conditional[IFTHEN_COND]);
3475                 else
3476                   func (stream, "s");
3477                 break;
3478
3479               case 'I':
3480                 {
3481                   unsigned int tmp;
3482
3483                   ifthen_next_state = given & 0xff;
3484                   for (tmp = given << 1; tmp & 0xf; tmp <<= 1)
3485                     func (stream, ((given ^ tmp) & 0x10) ? "e" : "t");
3486                   func (stream, "\t%s", arm_conditional[(given >> 4) & 0xf]);
3487                 }
3488                 break;
3489
3490               case 'x':
3491                 if (ifthen_next_state)
3492                   func (stream, "\t; unpredictable branch in IT block\n");
3493                 break;
3494
3495               case 'X':
3496                 if (ifthen_state)
3497                   func (stream, "\t; unpredictable <IT:%s>",
3498                         arm_conditional[IFTHEN_COND]);
3499                 break;
3500
3501               case 'S':
3502                 {
3503                   long reg;
3504
3505                   reg = (given >> 3) & 0x7;
3506                   if (given & (1 << 6))
3507                     reg += 8;
3508
3509                   func (stream, "%s", arm_regnames[reg]);
3510                 }
3511                 break;
3512
3513               case 'D':
3514                 {
3515                   long reg;
3516
3517                   reg = given & 0x7;
3518                   if (given & (1 << 7))
3519                     reg += 8;
3520
3521                   func (stream, "%s", arm_regnames[reg]);
3522                 }
3523                 break;
3524
3525               case 'N':
3526                 if (given & (1 << 8))
3527                   domasklr = 1;
3528                 /* Fall through.  */
3529               case 'O':
3530                 if (*c == 'O' && (given & (1 << 8)))
3531                   domaskpc = 1;
3532                 /* Fall through.  */
3533               case 'M':
3534                 {
3535                   int started = 0;
3536                   int reg;
3537
3538                   func (stream, "{");
3539
3540                   /* It would be nice if we could spot
3541                      ranges, and generate the rS-rE format: */
3542                   for (reg = 0; (reg < 8); reg++)
3543                     if ((given & (1 << reg)) != 0)
3544                       {
3545                         if (started)
3546                           func (stream, ", ");
3547                         started = 1;
3548                         func (stream, "%s", arm_regnames[reg]);
3549                       }
3550
3551                   if (domasklr)
3552                     {
3553                       if (started)
3554                         func (stream, ", ");
3555                       started = 1;
3556                       func (stream, arm_regnames[14] /* "lr" */);
3557                     }
3558
3559                   if (domaskpc)
3560                     {
3561                       if (started)
3562                         func (stream, ", ");
3563                       func (stream, arm_regnames[15] /* "pc" */);
3564                     }
3565
3566                   func (stream, "}");
3567                 }
3568                 break;
3569
3570               case 'W':
3571                 /* Print writeback indicator for a LDMIA.  We are doing a
3572                    writeback if the base register is not in the register
3573                    mask.  */
3574                 if ((given & (1 << ((given & 0x0700) >> 8))) == 0)
3575                   func (stream, "!");
3576                 break;
3577
3578               case 'b':
3579                 /* Print ARM V6T2 CZB address: pc+4+6 bits.  */
3580                 {
3581                   bfd_vma address = (pc + 4
3582                                      + ((given & 0x00f8) >> 2)
3583                                      + ((given & 0x0200) >> 3));
3584                   info->print_address_func (address, info);
3585                 }
3586                 break;
3587
3588               case 's':
3589                 /* Right shift immediate -- bits 6..10; 1-31 print
3590                    as themselves, 0 prints as 32.  */
3591                 {
3592                   long imm = (given & 0x07c0) >> 6;
3593                   if (imm == 0)
3594                     imm = 32;
3595                   func (stream, "#%ld", imm);
3596                 }
3597                 break;
3598
3599               case '0': case '1': case '2': case '3': case '4':
3600               case '5': case '6': case '7': case '8': case '9':
3601                 {
3602                   int bitstart = *c++ - '0';
3603                   int bitend = 0;
3604
3605                   while (*c >= '0' && *c <= '9')
3606                     bitstart = (bitstart * 10) + *c++ - '0';
3607
3608                   switch (*c)
3609                     {
3610                     case '-':
3611                       {
3612                         long reg;
3613
3614                         c++;
3615                         while (*c >= '0' && *c <= '9')
3616                           bitend = (bitend * 10) + *c++ - '0';
3617                         if (!bitend)
3618                           abort ();
3619                         reg = given >> bitstart;
3620                         reg &= (2 << (bitend - bitstart)) - 1;
3621
3622                         switch (*c)
3623                           {
3624                           case 'r':
3625                             func (stream, "%s", arm_regnames[reg]);
3626                             break;
3627
3628                           case 'd':
3629                             func (stream, "%ld", reg);
3630                             value_in_comment = reg;
3631                             break;
3632
3633                           case 'H':
3634                             func (stream, "%ld", reg << 1);
3635                             value_in_comment = reg << 1;
3636                             break;
3637
3638                           case 'W':
3639                             func (stream, "%ld", reg << 2);
3640                             value_in_comment = reg << 2;
3641                             break;
3642
3643                           case 'a':
3644                             /* PC-relative address -- the bottom two
3645                                bits of the address are dropped
3646                                before the calculation.  */
3647                             info->print_address_func
3648                               (((pc + 4) & ~3) + (reg << 2), info);
3649                             value_in_comment = 0;
3650                             break;
3651
3652                           case 'x':
3653                             func (stream, "0x%04lx", reg);
3654                             break;
3655
3656                           case 'B':
3657                             reg = ((reg ^ (1 << bitend)) - (1 << bitend));
3658                             info->print_address_func (reg * 2 + pc + 4, info);
3659                             value_in_comment = 0;
3660                             break;
3661
3662                           case 'c':
3663                             func (stream, "%s", arm_conditional [reg]);
3664                             break;
3665
3666                           default:
3667                             abort ();
3668                           }
3669                       }
3670                       break;
3671
3672                     case '\'':
3673                       c++;
3674                       if ((given & (1 << bitstart)) != 0)
3675                         func (stream, "%c", *c);
3676                       break;
3677
3678                     case '?':
3679                       ++c;
3680                       if ((given & (1 << bitstart)) != 0)
3681                         func (stream, "%c", *c++);
3682                       else
3683                         func (stream, "%c", *++c);
3684                       break;
3685
3686                     default:
3687                       abort ();
3688                     }
3689                 }
3690                 break;
3691
3692               default:
3693                 abort ();
3694               }
3695           }
3696
3697         if (value_in_comment > 32 || value_in_comment < -16)
3698           func (stream, "\t; 0x%lx", value_in_comment);
3699         return;
3700       }
3701
3702   /* No match.  */
3703   abort ();
3704 }
3705
3706 /* Return the name of an V7M special register.  */
3707
3708 static const char *
3709 psr_name (int regno)
3710 {
3711   switch (regno)
3712     {
3713     case 0: return "APSR";
3714     case 1: return "IAPSR";
3715     case 2: return "EAPSR";
3716     case 3: return "PSR";
3717     case 5: return "IPSR";
3718     case 6: return "EPSR";
3719     case 7: return "IEPSR";
3720     case 8: return "MSP";
3721     case 9: return "PSP";
3722     case 16: return "PRIMASK";
3723     case 17: return "BASEPRI";
3724     case 18: return "BASEPRI_MAX";
3725     case 19: return "FAULTMASK";
3726     case 20: return "CONTROL";
3727     default: return "<unknown>";
3728     }
3729 }
3730
3731 /* Print one 32-bit Thumb instruction from PC on INFO->STREAM.  */
3732
3733 static void
3734 print_insn_thumb32 (bfd_vma pc, struct disassemble_info *info, long given)
3735 {
3736   const struct opcode32 *insn;
3737   void *stream = info->stream;
3738   fprintf_ftype func = info->fprintf_func;
3739
3740   if (print_insn_coprocessor (pc, info, given, TRUE))
3741     return;
3742
3743   if (print_insn_neon (info, given, TRUE))
3744     return;
3745
3746   for (insn = thumb32_opcodes; insn->assembler; insn++)
3747     if ((given & insn->mask) == insn->value)
3748       {
3749         bfd_boolean is_unpredictable = FALSE;
3750         signed long value_in_comment = 0;
3751         const char *c = insn->assembler;
3752
3753         for (; *c; c++)
3754           {
3755             if (*c != '%')
3756               {
3757                 func (stream, "%c", *c);
3758                 continue;
3759               }
3760
3761             switch (*++c)
3762               {
3763               case '%':
3764                 func (stream, "%%");
3765                 break;
3766
3767               case 'c':
3768                 if (ifthen_state)
3769                   func (stream, "%s", arm_conditional[IFTHEN_COND]);
3770                 break;
3771
3772               case 'x':
3773                 if (ifthen_next_state)
3774                   func (stream, "\t; unpredictable branch in IT block\n");
3775                 break;
3776
3777               case 'X':
3778                 if (ifthen_state)
3779                   func (stream, "\t; unpredictable <IT:%s>",
3780                         arm_conditional[IFTHEN_COND]);
3781                 break;
3782
3783               case 'I':
3784                 {
3785                   unsigned int imm12 = 0;
3786
3787                   imm12 |= (given & 0x000000ffu);
3788                   imm12 |= (given & 0x00007000u) >> 4;
3789                   imm12 |= (given & 0x04000000u) >> 15;
3790                   func (stream, "#%u", imm12);
3791                   value_in_comment = imm12;
3792                 }
3793                 break;
3794
3795               case 'M':
3796                 {
3797                   unsigned int bits = 0, imm, imm8, mod;
3798
3799                   bits |= (given & 0x000000ffu);
3800                   bits |= (given & 0x00007000u) >> 4;
3801                   bits |= (given & 0x04000000u) >> 15;
3802                   imm8 = (bits & 0x0ff);
3803                   mod = (bits & 0xf00) >> 8;
3804                   switch (mod)
3805                     {
3806                     case 0: imm = imm8; break;
3807                     case 1: imm = ((imm8 << 16) | imm8); break;
3808                     case 2: imm = ((imm8 << 24) | (imm8 << 8)); break;
3809                     case 3: imm = ((imm8 << 24) | (imm8 << 16) | (imm8 << 8) | imm8); break;
3810                     default:
3811                       mod  = (bits & 0xf80) >> 7;
3812                       imm8 = (bits & 0x07f) | 0x80;
3813                       imm  = (((imm8 << (32 - mod)) | (imm8 >> mod)) & 0xffffffff);
3814                     }
3815                   func (stream, "#%u", imm);
3816                   value_in_comment = imm;
3817                 }
3818                 break;
3819
3820               case 'J':
3821                 {
3822                   unsigned int imm = 0;
3823
3824                   imm |= (given & 0x000000ffu);
3825                   imm |= (given & 0x00007000u) >> 4;
3826                   imm |= (given & 0x04000000u) >> 15;
3827                   imm |= (given & 0x000f0000u) >> 4;
3828                   func (stream, "#%u", imm);
3829                   value_in_comment = imm;
3830                 }
3831                 break;
3832
3833               case 'K':
3834                 {
3835                   unsigned int imm = 0;
3836
3837                   imm |= (given & 0x000f0000u) >> 16;
3838                   imm |= (given & 0x00000ff0u) >> 0;
3839                   imm |= (given & 0x0000000fu) << 12;
3840                   func (stream, "#%u", imm);
3841                   value_in_comment = imm;
3842                 }
3843                 break;
3844
3845               case 'V':
3846                 {
3847                   unsigned int imm = 0;
3848
3849                   imm |= (given & 0x00000fffu);
3850                   imm |= (given & 0x000f0000u) >> 4;
3851                   func (stream, "#%u", imm);
3852                   value_in_comment = imm;
3853                 }
3854                 break;
3855
3856               case 'S':
3857                 {
3858                   unsigned int reg = (given & 0x0000000fu);
3859                   unsigned int stp = (given & 0x00000030u) >> 4;
3860                   unsigned int imm = 0;
3861                   imm |= (given & 0x000000c0u) >> 6;
3862                   imm |= (given & 0x00007000u) >> 10;
3863
3864                   func (stream, "%s", arm_regnames[reg]);
3865                   switch (stp)
3866                     {
3867                     case 0:
3868                       if (imm > 0)
3869                         func (stream, ", lsl #%u", imm);
3870                       break;
3871
3872                     case 1:
3873                       if (imm == 0)
3874                         imm = 32;
3875                       func (stream, ", lsr #%u", imm);
3876                       break;
3877
3878                     case 2:
3879                       if (imm == 0)
3880                         imm = 32;
3881                       func (stream, ", asr #%u", imm);
3882                       break;
3883
3884                     case 3:
3885                       if (imm == 0)
3886                         func (stream, ", rrx");
3887                       else
3888                         func (stream, ", ror #%u", imm);
3889                     }
3890                 }
3891                 break;
3892
3893               case 'a':
3894                 {
3895                   unsigned int Rn  = (given & 0x000f0000) >> 16;
3896                   unsigned int U   = ! NEGATIVE_BIT_SET;
3897                   unsigned int op  = (given & 0x00000f00) >> 8;
3898                   unsigned int i12 = (given & 0x00000fff);
3899                   unsigned int i8  = (given & 0x000000ff);
3900                   bfd_boolean writeback = FALSE, postind = FALSE;
3901                   int offset = 0;
3902
3903                   func (stream, "[%s", arm_regnames[Rn]);
3904                   if (U) /* 12-bit positive immediate offset.  */
3905                     {
3906                       offset = i12;
3907                       if (Rn != 15)
3908                         value_in_comment = offset;
3909                     }
3910                   else if (Rn == 15) /* 12-bit negative immediate offset.  */
3911                     offset = - (int) i12;
3912                   else if (op == 0x0) /* Shifted register offset.  */
3913                     {
3914                       unsigned int Rm = (i8 & 0x0f);
3915                       unsigned int sh = (i8 & 0x30) >> 4;
3916
3917                       func (stream, ", %s", arm_regnames[Rm]);
3918                       if (sh)
3919                         func (stream, ", lsl #%u", sh);
3920                       func (stream, "]");
3921                       break;
3922                     }
3923                   else switch (op)
3924                     {
3925                     case 0xE:  /* 8-bit positive immediate offset.  */
3926                       offset = i8;
3927                       break;
3928
3929                     case 0xC:  /* 8-bit negative immediate offset.  */
3930                       offset = -i8;
3931                       break;
3932
3933                     case 0xF:  /* 8-bit + preindex with wb.  */
3934                       offset = i8;
3935                       writeback = TRUE;
3936                       break;
3937
3938                     case 0xD:  /* 8-bit - preindex with wb.  */
3939                       offset = -i8;
3940                       writeback = TRUE;
3941                       break;
3942
3943                     case 0xB:  /* 8-bit + postindex.  */
3944                       offset = i8;
3945                       postind = TRUE;
3946                       break;
3947
3948                     case 0x9:  /* 8-bit - postindex.  */
3949                       offset = -i8;
3950                       postind = TRUE;
3951                       break;
3952
3953                     default:
3954                       func (stream, ", <undefined>]");
3955                       goto skip;
3956                     }
3957
3958                   if (postind)
3959                     func (stream, "], #%d", offset);
3960                   else
3961                     {
3962                       if (offset)
3963                         func (stream, ", #%d", offset);
3964                       func (stream, writeback ? "]!" : "]");
3965                     }
3966
3967                   if (Rn == 15)
3968                     {
3969                       func (stream, "\t; ");
3970                       info->print_address_func (((pc + 4) & ~3) + offset, info);
3971                     }
3972                 }
3973               skip:
3974                 break;
3975
3976               case 'A':
3977                 {
3978                   unsigned int U   = ! NEGATIVE_BIT_SET;
3979                   unsigned int W   = WRITEBACK_BIT_SET;
3980                   unsigned int Rn  = (given & 0x000f0000) >> 16;
3981                   unsigned int off = (given & 0x000000ff);
3982
3983                   func (stream, "[%s", arm_regnames[Rn]);
3984
3985                   if (PRE_BIT_SET)
3986                     {
3987                       if (off || !U)
3988                         {
3989                           func (stream, ", #%c%u", U ? '+' : '-', off * 4);
3990                           value_in_comment = off * 4 * U ? 1 : -1;
3991                         }
3992                       func (stream, "]");
3993                       if (W)
3994                         func (stream, "!");
3995                     }
3996                   else
3997                     {
3998                       func (stream, "], ");
3999                       if (W)
4000                         {
4001                           func (stream, "#%c%u", U ? '+' : '-', off * 4);
4002                           value_in_comment = off * 4 * U ? 1 : -1;
4003                         }
4004                       else
4005                         {
4006                           func (stream, "{%u}", off);
4007                           value_in_comment = off;
4008                         }
4009                     }
4010                 }
4011                 break;
4012
4013               case 'w':
4014                 {
4015                   unsigned int Sbit = (given & 0x01000000) >> 24;
4016                   unsigned int type = (given & 0x00600000) >> 21;
4017
4018                   switch (type)
4019                     {
4020                     case 0: func (stream, Sbit ? "sb" : "b"); break;
4021                     case 1: func (stream, Sbit ? "sh" : "h"); break;
4022                     case 2:
4023                       if (Sbit)
4024                         func (stream, "??");
4025                       break;
4026                     case 3:
4027                       func (stream, "??");
4028                       break;
4029                     }
4030                 }
4031                 break;
4032
4033               case 'm':
4034                 {
4035                   int started = 0;
4036                   int reg;
4037
4038                   func (stream, "{");
4039                   for (reg = 0; reg < 16; reg++)
4040                     if ((given & (1 << reg)) != 0)
4041                       {
4042                         if (started)
4043                           func (stream, ", ");
4044                         started = 1;
4045                         func (stream, "%s", arm_regnames[reg]);
4046                       }
4047                   func (stream, "}");
4048                 }
4049                 break;
4050
4051               case 'E':
4052                 {
4053                   unsigned int msb = (given & 0x0000001f);
4054                   unsigned int lsb = 0;
4055
4056                   lsb |= (given & 0x000000c0u) >> 6;
4057                   lsb |= (given & 0x00007000u) >> 10;
4058                   func (stream, "#%u, #%u", lsb, msb - lsb + 1);
4059                 }
4060                 break;
4061
4062               case 'F':
4063                 {
4064                   unsigned int width = (given & 0x0000001f) + 1;
4065                   unsigned int lsb = 0;
4066
4067                   lsb |= (given & 0x000000c0u) >> 6;
4068                   lsb |= (given & 0x00007000u) >> 10;
4069                   func (stream, "#%u, #%u", lsb, width);
4070                 }
4071                 break;
4072
4073               case 'b':
4074                 {
4075                   unsigned int S = (given & 0x04000000u) >> 26;
4076                   unsigned int J1 = (given & 0x00002000u) >> 13;
4077                   unsigned int J2 = (given & 0x00000800u) >> 11;
4078                   int offset = 0;
4079
4080                   offset |= !S << 20;
4081                   offset |= J2 << 19;
4082                   offset |= J1 << 18;
4083                   offset |= (given & 0x003f0000) >> 4;
4084                   offset |= (given & 0x000007ff) << 1;
4085                   offset -= (1 << 20);
4086
4087                   info->print_address_func (pc + 4 + offset, info);
4088                 }
4089                 break;
4090
4091               case 'B':
4092                 {
4093                   unsigned int S = (given & 0x04000000u) >> 26;
4094                   unsigned int I1 = (given & 0x00002000u) >> 13;
4095                   unsigned int I2 = (given & 0x00000800u) >> 11;
4096                   int offset = 0;
4097
4098                   offset |= !S << 24;
4099                   offset |= !(I1 ^ S) << 23;
4100                   offset |= !(I2 ^ S) << 22;
4101                   offset |= (given & 0x03ff0000u) >> 4;
4102                   offset |= (given & 0x000007ffu) << 1;
4103                   offset -= (1 << 24);
4104                   offset += pc + 4;
4105
4106                   /* BLX target addresses are always word aligned.  */
4107                   if ((given & 0x00001000u) == 0)
4108                       offset &= ~2u;
4109
4110                   info->print_address_func (offset, info);
4111                 }
4112                 break;
4113
4114               case 's':
4115                 {
4116                   unsigned int shift = 0;
4117
4118                   shift |= (given & 0x000000c0u) >> 6;
4119                   shift |= (given & 0x00007000u) >> 10;
4120                   if (WRITEBACK_BIT_SET)
4121                     func (stream, ", asr #%u", shift);
4122                   else if (shift)
4123                     func (stream, ", lsl #%u", shift);
4124                   /* else print nothing - lsl #0 */
4125                 }
4126                 break;
4127
4128               case 'R':
4129                 {
4130                   unsigned int rot = (given & 0x00000030) >> 4;
4131
4132                   if (rot)
4133                     func (stream, ", ror #%u", rot * 8);
4134                 }
4135                 break;
4136
4137               case 'U':
4138                 if ((given & 0xf0) == 0x60)
4139                   {
4140                     switch (given & 0xf)
4141                       {
4142                         case 0xf: func (stream, "sy"); break;
4143                         default:
4144                           func (stream, "#%d", (int) given & 0xf);
4145                               break;
4146                       }
4147                   }
4148                 else
4149                   {
4150                     switch (given & 0xf)
4151                       {
4152                         case 0xf: func (stream, "sy"); break;
4153                         case 0x7: func (stream, "un"); break;
4154                         case 0xe: func (stream, "st"); break;
4155                         case 0x6: func (stream, "unst"); break;
4156                         case 0xb: func (stream, "ish"); break;
4157                         case 0xa: func (stream, "ishst"); break;
4158                         case 0x3: func (stream, "osh"); break;
4159                         case 0x2: func (stream, "oshst"); break;
4160                         default:
4161                           func (stream, "#%d", (int) given & 0xf);
4162                           break;
4163                       }
4164                    }
4165                 break;
4166
4167               case 'C':
4168                 if ((given & 0xff) == 0)
4169                   {
4170                     func (stream, "%cPSR_", (given & 0x100000) ? 'S' : 'C');
4171                     if (given & 0x800)
4172                       func (stream, "f");
4173                     if (given & 0x400)
4174                       func (stream, "s");
4175                     if (given & 0x200)
4176                       func (stream, "x");
4177                     if (given & 0x100)
4178                       func (stream, "c");
4179                   }
4180                 else if ((given & 0x20) == 0x20)
4181                   {
4182                     char const* name;
4183                     unsigned sysm = (given & 0xf00) >> 8;
4184
4185                     sysm |= (given & 0x30);
4186                     sysm |= (given & 0x00100000) >> 14;
4187                     name = banked_regname (sysm);
4188
4189                     if (name != NULL)
4190                       func (stream, "%s", name);
4191                     else
4192                       func (stream, "(UNDEF: %lu)", sysm);
4193                   }
4194                 else if ((given & 0xff) <= 3)
4195                   {
4196                     func (stream, "%s_", psr_name (given & 0xff));
4197
4198                     if (given & 0x800)
4199                       func (stream, "nzcvq");
4200                     if (given & 0x400)
4201                       func (stream, "g");
4202                   }
4203                 else
4204                   {
4205                     func (stream, psr_name (given & 0xff));
4206                   }
4207                 break;
4208
4209               case 'D':
4210                 if (((given & 0xff) == 0)
4211                     || ((given & 0x20) == 0x20))
4212                   {
4213                     char const* name;
4214                     unsigned sm = (given & 0xf0000) >> 16;
4215
4216                     sm |= (given & 0x30);
4217                     sm |= (given & 0x00100000) >> 14;
4218                     name = banked_regname (sm);
4219
4220                     if (name != NULL)
4221                       func (stream, "%s", name);
4222                     else
4223                       func (stream, "(UNDEF: %lu)", sm);
4224                   }
4225                 else
4226                   func (stream, psr_name (given & 0xff));
4227                 break;
4228
4229               case '0': case '1': case '2': case '3': case '4':
4230               case '5': case '6': case '7': case '8': case '9':
4231                 {
4232                   int width;
4233                   unsigned long val;
4234
4235                   c = arm_decode_bitfield (c, given, &val, &width);
4236
4237                   switch (*c)
4238                     {
4239                     case 'd':
4240                       func (stream, "%lu", val);
4241                       value_in_comment = val;
4242                       break;
4243
4244                     case 'W':
4245                       func (stream, "%lu", val * 4);
4246                       value_in_comment = val * 4;
4247                       break;
4248
4249                     case 'R':
4250                       if (val == 15)
4251                         is_unpredictable = TRUE;
4252                       /* Fall through.  */
4253                     case 'r':
4254                       func (stream, "%s", arm_regnames[val]);
4255                       break;
4256
4257                     case 'c':
4258                       func (stream, "%s", arm_conditional[val]);
4259                       break;
4260
4261                     case '\'':
4262                       c++;
4263                       if (val == ((1ul << width) - 1))
4264                         func (stream, "%c", *c);
4265                       break;
4266
4267                     case '`':
4268                       c++;
4269                       if (val == 0)
4270                         func (stream, "%c", *c);
4271                       break;
4272
4273                     case '?':
4274                       func (stream, "%c", c[(1 << width) - (int) val]);
4275                       c += 1 << width;
4276                       break;
4277
4278                     case 'x':
4279                       func (stream, "0x%lx", val & 0xffffffffUL);
4280                       break;
4281
4282                     default:
4283                       abort ();
4284                     }
4285                 }
4286                 break;
4287
4288               default:
4289                 abort ();
4290               }
4291           }
4292
4293         if (value_in_comment > 32 || value_in_comment < -16)
4294           func (stream, "\t; 0x%lx", value_in_comment);
4295
4296         if (is_unpredictable)
4297           func (stream, UNPREDICTABLE_INSTRUCTION);
4298
4299         return;
4300       }
4301
4302   /* No match.  */
4303   abort ();
4304 }
4305
4306 /* Print data bytes on INFO->STREAM.  */
4307
4308 static void
4309 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED,
4310                  struct disassemble_info *info,
4311                  long given)
4312 {
4313   switch (info->bytes_per_chunk)
4314     {
4315     case 1:
4316       info->fprintf_func (info->stream, ".byte\t0x%02lx", given);
4317       break;
4318     case 2:
4319       info->fprintf_func (info->stream, ".short\t0x%04lx", given);
4320       break;
4321     case 4:
4322       info->fprintf_func (info->stream, ".word\t0x%08lx", given);
4323       break;
4324     default:
4325       abort ();
4326     }
4327 }
4328
4329 /* Disallow mapping symbols ($a, $b, $d, $t etc) from
4330    being displayed in symbol relative addresses.  */
4331
4332 bfd_boolean
4333 arm_symbol_is_valid (asymbol * sym,
4334                      struct disassemble_info * info ATTRIBUTE_UNUSED)
4335 {
4336   const char * name;
4337
4338   if (sym == NULL)
4339     return FALSE;
4340
4341   name = bfd_asymbol_name (sym);
4342
4343   return (name && *name != '$');
4344 }
4345
4346 /* Parse an individual disassembler option.  */
4347
4348 void
4349 parse_arm_disassembler_option (char *option)
4350 {
4351   if (option == NULL)
4352     return;
4353
4354   if (CONST_STRNEQ (option, "reg-names-"))
4355     {
4356       int i;
4357
4358       option += 10;
4359
4360       for (i = NUM_ARM_REGNAMES; i--;)
4361         if (strneq (option, regnames[i].name, strlen (regnames[i].name)))
4362           {
4363             regname_selected = i;
4364             break;
4365           }
4366
4367       if (i < 0)
4368         /* XXX - should break 'option' at following delimiter.  */
4369         fprintf (stderr, _("Unrecognised register name set: %s\n"), option);
4370     }
4371   else if (CONST_STRNEQ (option, "force-thumb"))
4372     force_thumb = 1;
4373   else if (CONST_STRNEQ (option, "no-force-thumb"))
4374     force_thumb = 0;
4375   else
4376     /* XXX - should break 'option' at following delimiter.  */
4377     fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
4378
4379   return;
4380 }
4381
4382 /* Parse the string of disassembler options, spliting it at whitespaces
4383    or commas.  (Whitespace separators supported for backwards compatibility).  */
4384
4385 static void
4386 parse_disassembler_options (char *options)
4387 {
4388   if (options == NULL)
4389     return;
4390
4391   while (*options)
4392     {
4393       parse_arm_disassembler_option (options);
4394
4395       /* Skip forward to next seperator.  */
4396       while ((*options) && (! ISSPACE (*options)) && (*options != ','))
4397         ++ options;
4398       /* Skip forward past seperators.  */
4399       while (ISSPACE (*options) || (*options == ','))
4400         ++ options;
4401     }
4402 }
4403
4404 /* Search back through the insn stream to determine if this instruction is
4405    conditionally executed.  */
4406
4407 static void
4408 find_ifthen_state (bfd_vma pc,
4409                    struct disassemble_info *info,
4410                    bfd_boolean little)
4411 {
4412   unsigned char b[2];
4413   unsigned int insn;
4414   int status;
4415   /* COUNT is twice the number of instructions seen.  It will be odd if we
4416      just crossed an instruction boundary.  */
4417   int count;
4418   int it_count;
4419   unsigned int seen_it;
4420   bfd_vma addr;
4421
4422   ifthen_address = pc;
4423   ifthen_state = 0;
4424
4425   addr = pc;
4426   count = 1;
4427   it_count = 0;
4428   seen_it = 0;
4429   /* Scan backwards looking for IT instructions, keeping track of where
4430      instruction boundaries are.  We don't know if something is actually an
4431      IT instruction until we find a definite instruction boundary.  */
4432   for (;;)
4433     {
4434       if (addr == 0 || info->symbol_at_address_func (addr, info))
4435         {
4436           /* A symbol must be on an instruction boundary, and will not
4437              be within an IT block.  */
4438           if (seen_it && (count & 1))
4439             break;
4440
4441           return;
4442         }
4443       addr -= 2;
4444       status = info->read_memory_func (addr, (bfd_byte *) b, 2, info);
4445       if (status)
4446         return;
4447
4448       if (little)
4449         insn = (b[0]) | (b[1] << 8);
4450       else
4451         insn = (b[1]) | (b[0] << 8);
4452       if (seen_it)
4453         {
4454           if ((insn & 0xf800) < 0xe800)
4455             {
4456               /* Addr + 2 is an instruction boundary.  See if this matches
4457                  the expected boundary based on the position of the last
4458                  IT candidate.  */
4459               if (count & 1)
4460                 break;
4461               seen_it = 0;
4462             }
4463         }
4464       if ((insn & 0xff00) == 0xbf00 && (insn & 0xf) != 0)
4465         {
4466           /* This could be an IT instruction.  */
4467           seen_it = insn;
4468           it_count = count >> 1;
4469         }
4470       if ((insn & 0xf800) >= 0xe800)
4471         count++;
4472       else
4473         count = (count + 2) | 1;
4474       /* IT blocks contain at most 4 instructions.  */
4475       if (count >= 8 && !seen_it)
4476         return;
4477     }
4478   /* We found an IT instruction.  */
4479   ifthen_state = (seen_it & 0xe0) | ((seen_it << it_count) & 0x1f);
4480   if ((ifthen_state & 0xf) == 0)
4481     ifthen_state = 0;
4482 }
4483
4484 /* Returns nonzero and sets *MAP_TYPE if the N'th symbol is a
4485    mapping symbol.  */
4486
4487 static int
4488 is_mapping_symbol (struct disassemble_info *info, int n,
4489                    enum map_type *map_type)
4490 {
4491   const char *name;
4492
4493   name = bfd_asymbol_name (info->symtab[n]);
4494   if (name[0] == '$' && (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
4495       && (name[2] == 0 || name[2] == '.'))
4496     {
4497       *map_type = ((name[1] == 'a') ? MAP_ARM
4498                    : (name[1] == 't') ? MAP_THUMB
4499                    : MAP_DATA);
4500       return TRUE;
4501     }
4502
4503   return FALSE;
4504 }
4505
4506 /* Try to infer the code type (ARM or Thumb) from a mapping symbol.
4507    Returns nonzero if *MAP_TYPE was set.  */
4508
4509 static int
4510 get_map_sym_type (struct disassemble_info *info,
4511                   int n,
4512                   enum map_type *map_type)
4513 {
4514   /* If the symbol is in a different section, ignore it.  */
4515   if (info->section != NULL && info->section != info->symtab[n]->section)
4516     return FALSE;
4517
4518   return is_mapping_symbol (info, n, map_type);
4519 }
4520
4521 /* Try to infer the code type (ARM or Thumb) from a non-mapping symbol.
4522    Returns nonzero if *MAP_TYPE was set.  */
4523
4524 static int
4525 get_sym_code_type (struct disassemble_info *info,
4526                    int n,
4527                    enum map_type *map_type)
4528 {
4529   elf_symbol_type *es;
4530   unsigned int type;
4531
4532   /* If the symbol is in a different section, ignore it.  */
4533   if (info->section != NULL && info->section != info->symtab[n]->section)
4534     return FALSE;
4535
4536   es = *(elf_symbol_type **)(info->symtab + n);
4537   type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
4538
4539   /* If the symbol has function type then use that.  */
4540   if (type == STT_FUNC || type == STT_GNU_IFUNC)
4541     {
4542       if (ARM_SYM_BRANCH_TYPE (&es->internal_elf_sym) == ST_BRANCH_TO_THUMB)
4543         *map_type = MAP_THUMB;
4544       else
4545         *map_type = MAP_ARM;
4546       return TRUE;
4547     }
4548
4549   return FALSE;
4550 }
4551
4552 /* Given a bfd_mach_arm_XXX value, this function fills in the fields
4553    of the supplied arm_feature_set structure with bitmasks indicating
4554    the support base architectures and coprocessor extensions.
4555
4556    FIXME: This could more efficiently implemented as a constant array,
4557    although it would also be less robust.  */
4558
4559 static void
4560 select_arm_features (unsigned long mach,
4561                      arm_feature_set * features)
4562 {
4563 #undef  ARM_FEATURE
4564 #define ARM_FEATURE(ARCH,CEXT) \
4565   features->core = (ARCH); \
4566   features->coproc = (CEXT) | FPU_FPA; \
4567   return
4568
4569   switch (mach)
4570     {
4571     case bfd_mach_arm_2:       ARM_ARCH_V2;
4572     case bfd_mach_arm_2a:      ARM_ARCH_V2S;
4573     case bfd_mach_arm_3:       ARM_ARCH_V3;
4574     case bfd_mach_arm_3M:      ARM_ARCH_V3M;
4575     case bfd_mach_arm_4:       ARM_ARCH_V4;
4576     case bfd_mach_arm_4T:      ARM_ARCH_V4T;
4577     case bfd_mach_arm_5:       ARM_ARCH_V5;
4578     case bfd_mach_arm_5T:      ARM_ARCH_V5T;
4579     case bfd_mach_arm_5TE:     ARM_ARCH_V5TE;
4580     case bfd_mach_arm_XScale:  ARM_ARCH_XSCALE;
4581     case bfd_mach_arm_ep9312:  ARM_FEATURE (ARM_AEXT_V4T, ARM_CEXT_MAVERICK | FPU_MAVERICK);
4582     case bfd_mach_arm_iWMMXt:  ARM_ARCH_IWMMXT;
4583     case bfd_mach_arm_iWMMXt2: ARM_ARCH_IWMMXT2;
4584       /* If the machine type is unknown allow all
4585          architecture types and all extensions.  */
4586     case bfd_mach_arm_unknown: ARM_FEATURE (-1UL, -1UL);
4587     default:
4588       abort ();
4589     }
4590 }
4591
4592
4593 /* NOTE: There are no checks in these routines that
4594    the relevant number of data bytes exist.  */
4595
4596 static int
4597 print_insn (bfd_vma pc, struct disassemble_info *info, bfd_boolean little)
4598 {
4599   unsigned char b[4];
4600   long          given;
4601   int           status;
4602   int           is_thumb = FALSE;
4603   int           is_data = FALSE;
4604   int           little_code;
4605   unsigned int  size = 4;
4606   void          (*printer) (bfd_vma, struct disassemble_info *, long);
4607   bfd_boolean   found = FALSE;
4608   struct arm_private_data *private_data;
4609
4610   if (info->disassembler_options)
4611     {
4612       parse_disassembler_options (info->disassembler_options);
4613
4614       /* To avoid repeated parsing of these options, we remove them here.  */
4615       info->disassembler_options = NULL;
4616     }
4617
4618   /* PR 10288: Control which instructions will be disassembled.  */
4619   if (info->private_data == NULL)
4620     {
4621       static struct arm_private_data private;
4622
4623       if ((info->flags & USER_SPECIFIED_MACHINE_TYPE) == 0)
4624         /* If the user did not use the -m command line switch then default to
4625            disassembling all types of ARM instruction.
4626
4627            The info->mach value has to be ignored as this will be based on
4628            the default archictecture for the target and/or hints in the notes
4629            section, but it will never be greater than the current largest arm
4630            machine value (iWMMXt2), which is only equivalent to the V5TE
4631            architecture.  ARM architectures have advanced beyond the machine
4632            value encoding, and these newer architectures would be ignored if
4633            the machine value was used.
4634
4635            Ie the -m switch is used to restrict which instructions will be
4636            disassembled.  If it is necessary to use the -m switch to tell
4637            objdump that an ARM binary is being disassembled, eg because the
4638            input is a raw binary file, but it is also desired to disassemble
4639            all ARM instructions then use "-marm".  This will select the
4640            "unknown" arm architecture which is compatible with any ARM
4641            instruction.  */
4642           info->mach = bfd_mach_arm_unknown;
4643
4644       /* Compute the architecture bitmask from the machine number.
4645          Note: This assumes that the machine number will not change
4646          during disassembly....  */
4647       select_arm_features (info->mach, & private.features);
4648
4649       private.has_mapping_symbols = -1;
4650       private.last_mapping_sym = -1;
4651       private.last_mapping_addr = 0;
4652
4653       info->private_data = & private;
4654     }
4655
4656   private_data = info->private_data;
4657
4658   /* Decide if our code is going to be little-endian, despite what the
4659      function argument might say.  */
4660   little_code = ((info->endian_code == BFD_ENDIAN_LITTLE) || little);
4661
4662   /* For ELF, consult the symbol table to determine what kind of code
4663      or data we have.  */
4664   if (info->symtab_size != 0
4665       && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
4666     {
4667       bfd_vma addr;
4668       int n, start;
4669       int last_sym = -1;
4670       enum map_type type = MAP_ARM;
4671
4672       /* Start scanning at the start of the function, or wherever
4673          we finished last time.  */
4674       start = info->symtab_pos + 1;
4675       if (start < private_data->last_mapping_sym)
4676         start = private_data->last_mapping_sym;
4677       found = FALSE;
4678
4679       /* First, look for mapping symbols.  */
4680       if (private_data->has_mapping_symbols != 0)
4681         {
4682           /* Scan up to the location being disassembled.  */
4683           for (n = start; n < info->symtab_size; n++)
4684             {
4685               addr = bfd_asymbol_value (info->symtab[n]);
4686               if (addr > pc)
4687                 break;
4688               if (get_map_sym_type (info, n, &type))
4689                 {
4690                   last_sym = n;
4691                   found = TRUE;
4692                 }
4693             }
4694
4695           if (!found)
4696             {
4697               /* No mapping symbol found at this address.  Look backwards
4698                  for a preceeding one.  */
4699               for (n = start - 1; n >= 0; n--)
4700                 {
4701                   if (get_map_sym_type (info, n, &type))
4702                     {
4703                       last_sym = n;
4704                       found = TRUE;
4705                       break;
4706                     }
4707                 }
4708             }
4709
4710           if (found)
4711             private_data->has_mapping_symbols = 1;
4712
4713           /* No mapping symbols were found.  A leading $d may be
4714              omitted for sections which start with data; but for
4715              compatibility with legacy and stripped binaries, only
4716              assume the leading $d if there is at least one mapping
4717              symbol in the file.  */
4718           if (!found && private_data->has_mapping_symbols == -1)
4719             {
4720               /* Look for mapping symbols, in any section.  */
4721               for (n = 0; n < info->symtab_size; n++)
4722                 if (is_mapping_symbol (info, n, &type))
4723                   {
4724                     private_data->has_mapping_symbols = 1;
4725                     break;
4726                   }
4727               if (private_data->has_mapping_symbols == -1)
4728                 private_data->has_mapping_symbols = 0;
4729             }
4730
4731           if (!found && private_data->has_mapping_symbols == 1)
4732             {
4733               type = MAP_DATA;
4734               found = TRUE;
4735             }
4736         }
4737
4738       /* Next search for function symbols to separate ARM from Thumb
4739          in binaries without mapping symbols.  */
4740       if (!found)
4741         {
4742           /* Scan up to the location being disassembled.  */
4743           for (n = start; n < info->symtab_size; n++)
4744             {
4745               addr = bfd_asymbol_value (info->symtab[n]);
4746               if (addr > pc)
4747                 break;
4748               if (get_sym_code_type (info, n, &type))
4749                 {
4750                   last_sym = n;
4751                   found = TRUE;
4752                 }
4753             }
4754
4755           if (!found)
4756             {
4757               /* No mapping symbol found at this address.  Look backwards
4758                  for a preceeding one.  */
4759               for (n = start - 1; n >= 0; n--)
4760                 {
4761                   if (get_sym_code_type (info, n, &type))
4762                     {
4763                       last_sym = n;
4764                       found = TRUE;
4765                       break;
4766                     }
4767                 }
4768             }
4769         }
4770
4771       private_data->last_mapping_sym = last_sym;
4772       private_data->last_type = type;
4773       is_thumb = (private_data->last_type == MAP_THUMB);
4774       is_data = (private_data->last_type == MAP_DATA);
4775
4776       /* Look a little bit ahead to see if we should print out
4777          two or four bytes of data.  If there's a symbol,
4778          mapping or otherwise, after two bytes then don't
4779          print more.  */
4780       if (is_data)
4781         {
4782           size = 4 - (pc & 3);
4783           for (n = last_sym + 1; n < info->symtab_size; n++)
4784             {
4785               addr = bfd_asymbol_value (info->symtab[n]);
4786               if (addr > pc
4787                   && (info->section == NULL
4788                       || info->section == info->symtab[n]->section))
4789                 {
4790                   if (addr - pc < size)
4791                     size = addr - pc;
4792                   break;
4793                 }
4794             }
4795           /* If the next symbol is after three bytes, we need to
4796              print only part of the data, so that we can use either
4797              .byte or .short.  */
4798           if (size == 3)
4799             size = (pc & 1) ? 1 : 2;
4800         }
4801     }
4802
4803   if (info->symbols != NULL)
4804     {
4805       if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)
4806         {
4807           coff_symbol_type * cs;
4808
4809           cs = coffsymbol (*info->symbols);
4810           is_thumb = (   cs->native->u.syment.n_sclass == C_THUMBEXT
4811                       || cs->native->u.syment.n_sclass == C_THUMBSTAT
4812                       || cs->native->u.syment.n_sclass == C_THUMBLABEL
4813                       || cs->native->u.syment.n_sclass == C_THUMBEXTFUNC
4814                       || cs->native->u.syment.n_sclass == C_THUMBSTATFUNC);
4815         }
4816       else if (bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
4817                && !found)
4818         {
4819           /* If no mapping symbol has been found then fall back to the type
4820              of the function symbol.  */
4821           elf_symbol_type *  es;
4822           unsigned int       type;
4823
4824           es = *(elf_symbol_type **)(info->symbols);
4825           type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
4826
4827           is_thumb = ((ARM_SYM_BRANCH_TYPE (&es->internal_elf_sym)
4828                        == ST_BRANCH_TO_THUMB)
4829                       || type == STT_ARM_16BIT);
4830         }
4831     }
4832
4833   if (force_thumb)
4834     is_thumb = TRUE;
4835
4836   if (is_data)
4837     info->display_endian = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;
4838   else
4839     info->display_endian = little_code ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;
4840
4841   info->bytes_per_line = 4;
4842
4843   /* PR 10263: Disassemble data if requested to do so by the user.  */
4844   if (is_data && ((info->flags & DISASSEMBLE_DATA) == 0))
4845     {
4846       int i;
4847
4848       /* Size was already set above.  */
4849       info->bytes_per_chunk = size;
4850       printer = print_insn_data;
4851
4852       status = info->read_memory_func (pc, (bfd_byte *) b, size, info);
4853       given = 0;
4854       if (little)
4855         for (i = size - 1; i >= 0; i--)
4856           given = b[i] | (given << 8);
4857       else
4858         for (i = 0; i < (int) size; i++)
4859           given = b[i] | (given << 8);
4860     }
4861   else if (!is_thumb)
4862     {
4863       /* In ARM mode endianness is a straightforward issue: the instruction
4864          is four bytes long and is either ordered 0123 or 3210.  */
4865       printer = print_insn_arm;
4866       info->bytes_per_chunk = 4;
4867       size = 4;
4868
4869       status = info->read_memory_func (pc, (bfd_byte *) b, 4, info);
4870       if (little_code)
4871         given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
4872       else
4873         given = (b[3]) | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
4874     }
4875   else
4876     {
4877       /* In Thumb mode we have the additional wrinkle of two
4878          instruction lengths.  Fortunately, the bits that determine
4879          the length of the current instruction are always to be found
4880          in the first two bytes.  */
4881       printer = print_insn_thumb16;
4882       info->bytes_per_chunk = 2;
4883       size = 2;
4884
4885       status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);
4886       if (little_code)
4887         given = (b[0]) | (b[1] << 8);
4888       else
4889         given = (b[1]) | (b[0] << 8);
4890
4891       if (!status)
4892         {
4893           /* These bit patterns signal a four-byte Thumb
4894              instruction.  */
4895           if ((given & 0xF800) == 0xF800
4896               || (given & 0xF800) == 0xF000
4897               || (given & 0xF800) == 0xE800)
4898             {
4899               status = info->read_memory_func (pc + 2, (bfd_byte *) b, 2, info);
4900               if (little_code)
4901                 given = (b[0]) | (b[1] << 8) | (given << 16);
4902               else
4903                 given = (b[1]) | (b[0] << 8) | (given << 16);
4904
4905               printer = print_insn_thumb32;
4906               size = 4;
4907             }
4908         }
4909
4910       if (ifthen_address != pc)
4911         find_ifthen_state (pc, info, little_code);
4912
4913       if (ifthen_state)
4914         {
4915           if ((ifthen_state & 0xf) == 0x8)
4916             ifthen_next_state = 0;
4917           else
4918             ifthen_next_state = (ifthen_state & 0xe0)
4919                                 | ((ifthen_state & 0xf) << 1);
4920         }
4921     }
4922
4923   if (status)
4924     {
4925       info->memory_error_func (status, pc, info);
4926       return -1;
4927     }
4928   if (info->flags & INSN_HAS_RELOC)
4929     /* If the instruction has a reloc associated with it, then
4930        the offset field in the instruction will actually be the
4931        addend for the reloc.  (We are using REL type relocs).
4932        In such cases, we can ignore the pc when computing
4933        addresses, since the addend is not currently pc-relative.  */
4934     pc = 0;
4935
4936   printer (pc, info, given);
4937
4938   if (is_thumb)
4939     {
4940       ifthen_state = ifthen_next_state;
4941       ifthen_address += size;
4942     }
4943   return size;
4944 }
4945
4946 int
4947 print_insn_big_arm (bfd_vma pc, struct disassemble_info *info)
4948 {
4949   /* Detect BE8-ness and record it in the disassembler info.  */
4950   if (info->flavour == bfd_target_elf_flavour
4951       && info->section != NULL
4952       && (elf_elfheader (info->section->owner)->e_flags & EF_ARM_BE8))
4953     info->endian_code = BFD_ENDIAN_LITTLE;
4954
4955   return print_insn (pc, info, FALSE);
4956 }
4957
4958 int
4959 print_insn_little_arm (bfd_vma pc, struct disassemble_info *info)
4960 {
4961   return print_insn (pc, info, TRUE);
4962 }
4963
4964 void
4965 print_arm_disassembler_options (FILE *stream)
4966 {
4967   int i;
4968
4969   fprintf (stream, _("\n\
4970 The following ARM specific disassembler options are supported for use with\n\
4971 the -M switch:\n"));
4972
4973   for (i = NUM_ARM_REGNAMES; i--;)
4974     fprintf (stream, "  reg-names-%s %*c%s\n",
4975              regnames[i].name,
4976              (int)(14 - strlen (regnames[i].name)), ' ',
4977              regnames[i].description);
4978
4979   fprintf (stream, "  force-thumb              Assume all insns are Thumb insns\n");
4980   fprintf (stream, "  no-force-thumb           Examine preceeding label to determine an insn's type\n\n");
4981 }