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