opcodes/arm-dis.c

   1 /* Instruction printing code for the ARM
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   3    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 program is free software; you can redistribute it and/or modify it under
  10    the terms of the GNU General Public License as published by the Free
  11    Software Foundation; either version 2 of the License, or (at your option)
  12    any later version.
  13
  14    This program is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17    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, MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24
  25 #include "dis-asm.h"
  26 #include "opcode/arm.h"
  27 #include "opintl.h"
  28 #include "safe-ctype.h"
  29
  30 /* FIXME: This shouldn't be done here.  */
  31 #include "coff/internal.h"
  32 #include "libcoff.h"
  33 #include "elf-bfd.h"
  34 #include "elf/internal.h"
  35 #include "elf/arm.h"
  36
  37 /* FIXME: Belongs in global header.  */
  38 #ifndef strneq
  39 #define strneq(a,b,n)   (strncmp ((a), (b), (n)) == 0)
  40 #endif
  41
  42 #ifndef NUM_ELEM
  43 #define NUM_ELEM(a)     (sizeof (a) / sizeof (a)[0])
  44 #endif
  45
  46 struct opcode32
  47 {
  48   unsigned long arch;           /* Architecture defining this insn.  */
  49   unsigned long value, mask;    /* Recognise insn if (op&mask)==value.  */
  50   const char *assembler;        /* How to disassemble this insn.  */
  51 };
  52
  53 struct opcode16
  54 {
  55   unsigned long arch;           /* Architecture defining this insn.  */
  56   unsigned short value, mask;   /* Recognise insn if (op&mask)==value.  */
  57   const char *assembler;        /* How to disassemble this insn.  */
  58 };
  59
  60 /* Opcode tables: ARM, 16-bit Thumb, 32-bit Thumb.  All three are partially
  61    ordered: they must be searched linearly from the top to obtain a correct
  62    match.  */
  63
  64 /* print_insn_arm recognizes the following format control codes:
  65
  66    %%                   %
  67
  68    %a                   print address for ldr/str instruction
  69    %s                   print address for ldr/str halfword/signextend instruction
  70    %b                   print branch destination
  71    %c                   print condition code (always bits 28-31)
  72    %m                   print register mask for ldm/stm instruction
  73    %o                   print operand2 (immediate or register + shift)
  74    %p                   print 'p' iff bits 12-15 are 15
  75    %t                   print 't' iff bit 21 set and bit 24 clear
  76    %A                   print address for ldc/stc/ldf/stf instruction
  77    %B                   print arm BLX(1) destination
  78    %I                   print cirrus signed shift immediate: bits 0..3|4..6
  79    %C                   print the PSR sub type.
  80    %F                   print the COUNT field of a LFM/SFM instruction.
  81    %P                   print floating point precision in arithmetic insn
  82    %Q                   print floating point precision in ldf/stf insn
  83    %R                   print floating point rounding mode
  84
  85    %<bitfield>r         print as an ARM register
  86    %<bitfield>d         print the bitfield in decimal
  87    %<bitfield>W         print the bitfield plus one in decimal
  88    %<bitfield>x         print the bitfield in hex
  89    %<bitfield>X         print the bitfield as 1 hex digit without leading "0x"
  90    %<bitfield>f         print a floating point constant if >7 else a
  91                         floating point register
  92    %<bitfield>w         print as an iWMMXt width field - [bhwd]ss/us
  93    %<bitfield>g         print as an iWMMXt 64-bit register
  94    %<bitfield>G         print as an iWMMXt general purpose or control register
  95
  96    %<code>y             print a single precision VFP reg.
  97                           Codes: 0=>Sm, 1=>Sd, 2=>Sn, 3=>multi-list, 4=>Sm pair
  98    %<code>z             print a double precision VFP reg
  99                           Codes: 0=>Dm, 1=>Dd, 2=>Dn, 3=>multi-list
 100    %<bitnum>'c          print specified char iff bit is one
 101    %<bitnum>`c          print specified char iff bit is zero
 102    %<bitnum>?ab         print a if bit is one else print b
 103
 104    %L                   print as an iWMMXt N/M width field.
 105    %Z                   print the Immediate of a WSHUFH instruction.
 106    %l                   like 'A' except use byte offsets for 'B' & 'H' versions.
 107
 108    %e                   print arm SMI operand (bits 0..7,8..19).
 109    %E                   print the LSB and WIDTH fields of a BFI or BFC instruction.
 110    %V                   print the 16-bit immediate field of a MOVT or MOVW instruction.  */
 111
 112 static const struct opcode32 arm_opcodes[] =
 113 {
 114   /* ARM instructions.  */
 115   {ARM_EXT_V1, 0xe1a00000, 0xffffffff, "nop\t\t\t(mov r0,r0)"},
 116   {ARM_EXT_V4T | ARM_EXT_V5, 0x012FFF10, 0x0ffffff0, "bx%c\t%0-3r"},
 117   {ARM_EXT_V2, 0x00000090, 0x0fe000f0, "mul%c%20's\t%16-19r, %0-3r, %8-11r"},
 118   {ARM_EXT_V2, 0x00200090, 0x0fe000f0, "mla%c%20's\t%16-19r, %0-3r, %8-11r, %12-15r"},
 119   {ARM_EXT_V2S, 0x01000090, 0x0fb00ff0, "swp%c%22'b\t%12-15r, %0-3r, [%16-19r]"},
 120   {ARM_EXT_V3M, 0x00800090, 0x0fa000f0, "%22?sumull%c%20's\t%12-15r, %16-19r, %0-3r, %8-11r"},
 121   {ARM_EXT_V3M, 0x00a00090, 0x0fa000f0, "%22?sumlal%c%20's\t%12-15r, %16-19r, %0-3r, %8-11r"},
 122
 123   /* ARM V6T2 instructions.  */
 124   {ARM_EXT_V6T2, 0x07c0001f, 0x0fe0007f, "bfc%c\t%12-15r, %E"},
 125   {ARM_EXT_V6T2, 0x07c00010, 0x0fe00070, "bfi%c\t%12-15r, %0-3r, %E"},
 126   {ARM_EXT_V6T2, 0x00600090, 0x0ff000f0, "mls%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 127   {ARM_EXT_V6T2, 0x006000b0, 0x0f7000f0, "str%cht\t%12-15r, %s"},
 128   {ARM_EXT_V6T2, 0x00300090, 0x0f300090, "ldr%c%6's%5?hbt\t%12-15r, %s"},
 129   {ARM_EXT_V6T2, 0x03000000, 0x0ff00000, "movw%c\t%12-15r, %V"},
 130   {ARM_EXT_V6T2, 0x03400000, 0x0ff00000, "movt%c\t%12-15r, %V"},
 131   {ARM_EXT_V6T2, 0x03ff0f30, 0x0fff0ff0, "rbit%c\t%12-15r, %0-3r"},
 132   {ARM_EXT_V6T2, 0x07a00050, 0x0fa00070, "%22?usbfx%c\t%12-15r, %0-3r, #%7-11d, #%16-20W"},
 133
 134   /* ARM V6Z instructions.  */
 135   {ARM_EXT_V6Z, 0x01600070, 0x0ff000f0, "smi%c\t%e"},
 136
 137   /* ARM V6K instructions.  */
 138   {ARM_EXT_V6K, 0xf57ff01f, 0xffffffff, "clrex"},
 139   {ARM_EXT_V6K, 0x01d00f9f, 0x0ff00fff, "ldrexb%c\t%12-15r, [%16-19r]"},
 140   {ARM_EXT_V6K, 0x01b00f9f, 0x0ff00fff, "ldrexd%c\t%12-15r, [%16-19r]"},
 141   {ARM_EXT_V6K, 0x01f00f9f, 0x0ff00fff, "ldrexh%c\t%12-15r, [%16-19r]"},
 142   {ARM_EXT_V6K, 0x01c00f90, 0x0ff00ff0, "strexb%c\t%12-15r, %0-3r, [%16-19r]"},
 143   {ARM_EXT_V6K, 0x01a00f90, 0x0ff00ff0, "strexd%c\t%12-15r, %0-3r, [%16-19r]"},
 144   {ARM_EXT_V6K, 0x01e00f90, 0x0ff00ff0, "strexh%c\t%12-15r, %0-3r, [%16-19r]"},
 145
 146   /* ARM V6K NOP hints.  */
 147   {ARM_EXT_V6K, 0x0320f001, 0x0fffffff, "yield%c"},
 148   {ARM_EXT_V6K, 0x0320f002, 0x0fffffff, "wfe%c"},
 149   {ARM_EXT_V6K, 0x0320f003, 0x0fffffff, "wfi%c"},
 150   {ARM_EXT_V6K, 0x0320f004, 0x0fffffff, "sev%c"},
 151   {ARM_EXT_V6K, 0x0320f000, 0x0fffff00, "nop%c\t{%0-7d}"},
 152
 153   /* ARM V6 instructions. */
 154   {ARM_EXT_V6, 0xfc500000, 0xfff00000, "mrrc2\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 155   {ARM_EXT_V6, 0xfc400000, 0xfff00000, "mcrr2\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 156   {ARM_EXT_V6, 0xf1080000, 0xfffdfe3f, "cpsie\t%8'a%7'i%6'f"},
 157   {ARM_EXT_V6, 0xf1080000, 0xfffdfe20, "cpsie\t%8'a%7'i%6'f,#%0-4d"},
 158   {ARM_EXT_V6, 0xf10C0000, 0xfffdfe3f, "cpsid\t%8'a%7'i%6'f"},
 159   {ARM_EXT_V6, 0xf10C0000, 0xfffdfe20, "cpsid\t%8'a%7'i%6'f,#%0-4d"},
 160   {ARM_EXT_V6, 0xf1000000, 0xfff1fe20, "cps\t#%0-4d"},
 161   {ARM_EXT_V6, 0x06800010, 0x0ff00ff0, "pkhbt%c\t%12-15r, %16-19r, %0-3r"},
 162   {ARM_EXT_V6, 0x06800010, 0x0ff00070, "pkhbt%c\t%12-15r, %16-19r, %0-3r, LSL #%7-11d"},
 163   {ARM_EXT_V6, 0x06800050, 0x0ff00ff0, "pkhtb%c\t%12-15r, %16-19r, %0-3r, ASR #32"},
 164   {ARM_EXT_V6, 0x06800050, 0x0ff00070, "pkhtb%c\t%12-15r, %16-19r, %0-3r, ASR #%7-11d"},
 165   {ARM_EXT_V6, 0x01900f9f, 0x0ff00fff, "ldrex%c\tr%12-15d, [%16-19r]"},
 166   {ARM_EXT_V6, 0x06200f10, 0x0ff00ff0, "qadd16%c\t%12-15r, %16-19r, %0-3r"},
 167   {ARM_EXT_V6, 0x06200f90, 0x0ff00ff0, "qadd8%c\t%12-15r, %16-19r, %0-3r"},
 168   {ARM_EXT_V6, 0x06200f30, 0x0ff00ff0, "qaddsubx%c\t%12-15r, %16-19r, %0-3r"},
 169   {ARM_EXT_V6, 0x06200f70, 0x0ff00ff0, "qsub16%c\t%12-15r, %16-19r, %0-3r"},
 170   {ARM_EXT_V6, 0x06200ff0, 0x0ff00ff0, "qsub8%c\t%12-15r, %16-19r, %0-3r"},
 171   {ARM_EXT_V6, 0x06200f50, 0x0ff00ff0, "qsubaddx%c\t%12-15r, %16-19r, %0-3r"},
 172   {ARM_EXT_V6, 0x06100f10, 0x0ff00ff0, "sadd16%c\t%12-15r, %16-19r, %0-3r"},
 173   {ARM_EXT_V6, 0x06100f90, 0x0ff00ff0, "sadd8%c\t%12-15r, %16-19r, %0-3r"},
 174   {ARM_EXT_V6, 0x06100f30, 0x0ff00ff0, "saddaddx%c\t%12-15r, %16-19r, %0-3r"},
 175   {ARM_EXT_V6, 0x06300f10, 0x0ff00ff0, "shadd16%c\t%12-15r, %16-19r, %0-3r"},
 176   {ARM_EXT_V6, 0x06300f90, 0x0ff00ff0, "shadd8%c\t%12-15r, %16-19r, %0-3r"},
 177   {ARM_EXT_V6, 0x06300f30, 0x0ff00ff0, "shaddsubx%c\t%12-15r, %16-19r, %0-3r"},
 178   {ARM_EXT_V6, 0x06300f70, 0x0ff00ff0, "shsub16%c\t%12-15r, %16-19r, %0-3r"},
 179   {ARM_EXT_V6, 0x06300ff0, 0x0ff00ff0, "shsub8%c\t%12-15r, %16-19r, %0-3r"},
 180   {ARM_EXT_V6, 0x06300f50, 0x0ff00ff0, "shsubaddx%c\t%12-15r, %16-19r, %0-3r"},
 181   {ARM_EXT_V6, 0x06100f70, 0x0ff00ff0, "ssub16%c\t%12-15r, %16-19r, %0-3r"},
 182   {ARM_EXT_V6, 0x06100ff0, 0x0ff00ff0, "ssub8%c\t%12-15r, %16-19r, %0-3r"},
 183   {ARM_EXT_V6, 0x06100f50, 0x0ff00ff0, "ssubaddx%c\t%12-15r, %16-19r, %0-3r"},
 184   {ARM_EXT_V6, 0x06500f10, 0x0ff00ff0, "uadd16%c\t%12-15r, %16-19r, %0-3r"},
 185   {ARM_EXT_V6, 0x06500f90, 0x0ff00ff0, "uadd8%c\t%12-15r, %16-19r, %0-3r"},
 186   {ARM_EXT_V6, 0x06500f30, 0x0ff00ff0, "uaddsubx%c\t%12-15r, %16-19r, %0-3r"},
 187   {ARM_EXT_V6, 0x06700f10, 0x0ff00ff0, "uhadd16%c\t%12-15r, %16-19r, %0-3r"},
 188   {ARM_EXT_V6, 0x06700f90, 0x0ff00ff0, "uhadd8%c\t%12-15r, %16-19r, %0-3r"},
 189   {ARM_EXT_V6, 0x06700f30, 0x0ff00ff0, "uhaddsubx%c\t%12-15r, %16-19r, %0-3r"},
 190   {ARM_EXT_V6, 0x06700f70, 0x0ff00ff0, "uhsub16%c\t%12-15r, %16-19r, %0-3r"},
 191   {ARM_EXT_V6, 0x06700ff0, 0x0ff00ff0, "uhsub8%c\t%12-15r, %16-19r, %0-3r"},
 192   {ARM_EXT_V6, 0x06700f50, 0x0ff00ff0, "uhsubaddx%c\t%12-15r, %16-19r, %0-3r"},
 193   {ARM_EXT_V6, 0x06600f10, 0x0ff00ff0, "uqadd16%c\t%12-15r, %16-19r, %0-3r"},
 194   {ARM_EXT_V6, 0x06600f90, 0x0ff00ff0, "uqadd8%c\t%12-15r, %16-19r, %0-3r"},
 195   {ARM_EXT_V6, 0x06600f30, 0x0ff00ff0, "uqaddsubx%c\t%12-15r, %16-19r, %0-3r"},
 196   {ARM_EXT_V6, 0x06600f70, 0x0ff00ff0, "uqsub16%c\t%12-15r, %16-19r, %0-3r"},
 197   {ARM_EXT_V6, 0x06600ff0, 0x0ff00ff0, "uqsub8%c\t%12-15r, %16-19r, %0-3r"},
 198   {ARM_EXT_V6, 0x06600f50, 0x0ff00ff0, "uqsubaddx%c\t%12-15r, %16-19r, %0-3r"},
 199   {ARM_EXT_V6, 0x06500f70, 0x0ff00ff0, "usub16%c\t%12-15r, %16-19r, %0-3r"},
 200   {ARM_EXT_V6, 0x06500ff0, 0x0ff00ff0, "usub8%c\t%12-15r, %16-19r, %0-3r"},
 201   {ARM_EXT_V6, 0x06500f50, 0x0ff00ff0, "usubaddx%c\t%12-15r, %16-19r, %0-3r"},
 202   {ARM_EXT_V6, 0x06bf0f30, 0x0fff0ff0, "rev%c\t\%12-15r, %0-3r"},
 203   {ARM_EXT_V6, 0x06bf0fb0, 0x0fff0ff0, "rev16%c\t\%12-15r, %0-3r"},
 204   {ARM_EXT_V6, 0x06ff0fb0, 0x0fff0ff0, "revsh%c\t\%12-15r, %0-3r"},
 205   {ARM_EXT_V6, 0xf8100a00, 0xfe50ffff, "rfe%23?id%24?ba\t\%16-19r%21'!"},
 206   {ARM_EXT_V6, 0x06bf0070, 0x0fff0ff0, "sxth%c %12-15r,%0-3r"},
 207   {ARM_EXT_V6, 0x06bf0470, 0x0fff0ff0, "sxth%c %12-15r,%0-3r, ROR #8"},
 208   {ARM_EXT_V6, 0x06bf0870, 0x0fff0ff0, "sxth%c %12-15r,%0-3r, ROR #16"},
 209   {ARM_EXT_V6, 0x06bf0c70, 0x0fff0ff0, "sxth%c %12-15r,%0-3r, ROR #24"},
 210   {ARM_EXT_V6, 0x068f0070, 0x0fff0ff0, "sxtb16%c %12-15r,%0-3r"},
 211   {ARM_EXT_V6, 0x068f0470, 0x0fff0ff0, "sxtb16%c %12-15r,%0-3r, ROR #8"},
 212   {ARM_EXT_V6, 0x068f0870, 0x0fff0ff0, "sxtb16%c %12-15r,%0-3r, ROR #16"},
 213   {ARM_EXT_V6, 0x068f0c70, 0x0fff0ff0, "sxtb16%c %12-15r,%0-3r, ROR #24"},
 214   {ARM_EXT_V6, 0x06af0070, 0x0fff0ff0, "sxtb%c %12-15r,%0-3r"},
 215   {ARM_EXT_V6, 0x06af0470, 0x0fff0ff0, "sxtb%c %12-15r,%0-3r, ROR #8"},
 216   {ARM_EXT_V6, 0x06af0870, 0x0fff0ff0, "sxtb%c %12-15r,%0-3r, ROR #16"},
 217   {ARM_EXT_V6, 0x06af0c70, 0x0fff0ff0, "sxtb%c %12-15r,%0-3r, ROR #24"},
 218   {ARM_EXT_V6, 0x06ff0070, 0x0fff0ff0, "uxth%c %12-15r,%0-3r"},
 219   {ARM_EXT_V6, 0x06ff0470, 0x0fff0ff0, "uxth%c %12-15r,%0-3r, ROR #8"},
 220   {ARM_EXT_V6, 0x06ff0870, 0x0fff0ff0, "uxth%c %12-15r,%0-3r, ROR #16"},
 221   {ARM_EXT_V6, 0x06ff0c70, 0x0fff0ff0, "uxth%c %12-15r,%0-3r, ROR #24"},
 222   {ARM_EXT_V6, 0x06cf0070, 0x0fff0ff0, "uxtb16%c %12-15r,%0-3r"},
 223   {ARM_EXT_V6, 0x06cf0470, 0x0fff0ff0, "uxtb16%c %12-15r,%0-3r, ROR #8"},
 224   {ARM_EXT_V6, 0x06cf0870, 0x0fff0ff0, "uxtb16%c %12-15r,%0-3r, ROR #16"},
 225   {ARM_EXT_V6, 0x06cf0c70, 0x0fff0ff0, "uxtb16%c %12-15r,%0-3r, ROR #24"},
 226   {ARM_EXT_V6, 0x06ef0070, 0x0fff0ff0, "uxtb%c %12-15r,%0-3r"},
 227   {ARM_EXT_V6, 0x06ef0470, 0x0fff0ff0, "uxtb%c %12-15r,%0-3r, ROR #8"},
 228   {ARM_EXT_V6, 0x06ef0870, 0x0fff0ff0, "uxtb%c %12-15r,%0-3r, ROR #16"},
 229   {ARM_EXT_V6, 0x06ef0c70, 0x0fff0ff0, "uxtb%c %12-15r,%0-3r, ROR #24"},
 230   {ARM_EXT_V6, 0x06b00070, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r"},
 231   {ARM_EXT_V6, 0x06b00470, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 232   {ARM_EXT_V6, 0x06b00870, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 233   {ARM_EXT_V6, 0x06b00c70, 0x0ff00ff0, "sxtah%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 234   {ARM_EXT_V6, 0x06800070, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r"},
 235   {ARM_EXT_V6, 0x06800470, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 236   {ARM_EXT_V6, 0x06800870, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 237   {ARM_EXT_V6, 0x06800c70, 0x0ff00ff0, "sxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 238   {ARM_EXT_V6, 0x06a00070, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r"},
 239   {ARM_EXT_V6, 0x06a00470, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 240   {ARM_EXT_V6, 0x06a00870, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 241   {ARM_EXT_V6, 0x06a00c70, 0x0ff00ff0, "sxtab%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 242   {ARM_EXT_V6, 0x06f00070, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r"},
 243   {ARM_EXT_V6, 0x06f00470, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 244   {ARM_EXT_V6, 0x06f00870, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 245   {ARM_EXT_V6, 0x06f00c70, 0x0ff00ff0, "uxtah%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 246   {ARM_EXT_V6, 0x06c00070, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r"},
 247   {ARM_EXT_V6, 0x06c00470, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 248   {ARM_EXT_V6, 0x06c00870, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 249   {ARM_EXT_V6, 0x06c00c70, 0x0ff00ff0, "uxtab16%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 250   {ARM_EXT_V6, 0x06e00070, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r"},
 251   {ARM_EXT_V6, 0x06e00470, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ROR #8"},
 252   {ARM_EXT_V6, 0x06e00870, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ROR #16"},
 253   {ARM_EXT_V6, 0x06e00c70, 0x0ff00ff0, "uxtab%c\t%12-15r, %16-19r, %0-3r, ROR #24"},
 254   {ARM_EXT_V6, 0x068000b0, 0x0ff00ff0, "sel%c\t%12-15r, %16-19r, %0-3r"},
 255   {ARM_EXT_V6, 0xf1010000, 0xfffffc00, "setend\t%9?ble"},
 256   {ARM_EXT_V6, 0x0700f010, 0x0ff0f0d0, "smuad%5'x%c\t%16-19r, %0-3r, %8-11r"},
 257   {ARM_EXT_V6, 0x0700f050, 0x0ff0f0d0, "smusd%5'x%c\t%16-19r, %0-3r, %8-11r"},
 258   {ARM_EXT_V6, 0x07000010, 0x0ff000d0, "smlad%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 259   {ARM_EXT_V6, 0x07400010, 0x0ff000d0, "smlald%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 260   {ARM_EXT_V6, 0x07000050, 0x0ff000d0, "smlsd%5'x%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 261   {ARM_EXT_V6, 0x07400050, 0x0ff000d0, "smlsld%5'x%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 262   {ARM_EXT_V6, 0x0750f010, 0x0ff0f0d0, "smmul%5'r%c\t%16-19r, %0-3r, %8-11r"},
 263   {ARM_EXT_V6, 0x07500010, 0x0ff000d0, "smmla%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 264   {ARM_EXT_V6, 0x075000d0, 0x0ff000d0, "smmls%5'r%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 265   {ARM_EXT_V6, 0xf84d0500, 0xfe5fffe0, "srs%23?id%24?ba\t#%0-4d%21'!"},
 266   {ARM_EXT_V6, 0x06a00010, 0x0fe00ff0, "ssat%c\t%12-15r, #%16-20W, %0-3r"},
 267   {ARM_EXT_V6, 0x06a00010, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, LSL #%7-11d"},
 268   {ARM_EXT_V6, 0x06a00050, 0x0fe00070, "ssat%c\t%12-15r, #%16-20W, %0-3r, ASR #%7-11d"},
 269   {ARM_EXT_V6, 0x06a00f30, 0x0ff00ff0, "ssat16%c\t%12-15r, #%16-19W, %0-3r"},
 270   {ARM_EXT_V6, 0x01800f90, 0x0ff00ff0, "strex%c\t%12-15r, %0-3r, [%16-19r]"},
 271   {ARM_EXT_V6, 0x00400090, 0x0ff000f0, "umaal%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 272   {ARM_EXT_V6, 0x0780f010, 0x0ff0f0f0, "usad8%c\t%16-19r, %0-3r, %8-11r"},
 273   {ARM_EXT_V6, 0x07800010, 0x0ff000f0, "usada8%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 274   {ARM_EXT_V6, 0x06e00010, 0x0fe00ff0, "usat%c\t%12-15r, #%16-20d, %0-3r"},
 275   {ARM_EXT_V6, 0x06e00010, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, LSL #%7-11d"},
 276   {ARM_EXT_V6, 0x06e00050, 0x0fe00070, "usat%c\t%12-15r, #%16-20d, %0-3r, ASR #%7-11d"},
 277   {ARM_EXT_V6, 0x06e00f30, 0x0ff00ff0, "usat16%c\t%12-15r, #%16-19d, %0-3r"},
 278
 279   /* V5J instruction.  */
 280   {ARM_EXT_V5J, 0x012fff20, 0x0ffffff0, "bxj%c\t%0-3r"},
 281
 282   /* XScale instructions.  */
 283   {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0ff0, "mia%c\tacc0, %0-3r, %12-15r"},
 284   {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0ff0, "miaph%c\tacc0, %0-3r, %12-15r"},
 285   {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0ff0, "mia%17'T%17`B%16'T%16`B%c\tacc0, %0-3r, %12-15r"},
 286   {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00fff, "mar%c\tacc0, %12-15r, %16-19r"},
 287   {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00fff, "mra%c\t%12-15r, %16-19r, acc0"},
 288
 289   /* Intel Wireless MMX technology instructions.  */
 290 #define FIRST_IWMMXT_INSN 0x0e130130
 291 #define IWMMXT_INSN_COUNT 47
 292   {ARM_CEXT_IWMMXT, 0x0e130130, 0x0f3f0fff, "tandc%22-23w%c\t%12-15r"},
 293   {ARM_CEXT_XSCALE, 0x0e400010, 0x0ff00f3f, "tbcst%6-7w%c\t%16-19g, %12-15r"},
 294   {ARM_CEXT_XSCALE, 0x0e130170, 0x0f3f0ff8, "textrc%22-23w%c\t%12-15r, #%0-2d"},
 295   {ARM_CEXT_XSCALE, 0x0e100070, 0x0f300ff0, "textrm%3?su%22-23w%c\t%12-15r, %16-19g, #%0-2d"},
 296   {ARM_CEXT_XSCALE, 0x0e600010, 0x0ff00f38, "tinsr%6-7w%c\t%16-19g, %12-15r, #%0-2d"},
 297   {ARM_CEXT_XSCALE, 0x0e000110, 0x0ff00fff, "tmcr%c\t%16-19G, %12-15r"},
 298   {ARM_CEXT_XSCALE, 0x0c400000, 0x0ff00ff0, "tmcrr%c\t%0-3g, %12-15r, %16-19r"},
 299   {ARM_CEXT_XSCALE, 0x0e2c0010, 0x0ffc0e10, "tmia%17?tb%16?tb%c\t%5-8g, %0-3r, %12-15r"},
 300   {ARM_CEXT_XSCALE, 0x0e200010, 0x0fff0e10, "tmia%c\t%5-8g, %0-3r, %12-15r"},
 301   {ARM_CEXT_XSCALE, 0x0e280010, 0x0fff0e10, "tmiaph%c\t%5-8g, %0-3r, %12-15r"},
 302   {ARM_CEXT_XSCALE, 0x0e100030, 0x0f300fff, "tmovmsk%22-23w%c\t%12-15r, %16-19g"},
 303   {ARM_CEXT_XSCALE, 0x0e100110, 0x0ff00ff0, "tmrc%c\t%12-15r, %16-19G"},
 304   {ARM_CEXT_XSCALE, 0x0c500000, 0x0ff00ff0, "tmrrc%c\t%12-15r, %16-19r, %0-3g"},
 305   {ARM_CEXT_XSCALE, 0x0e130150, 0x0f3f0fff, "torc%22-23w%c\t%12-15r"},
 306   {ARM_CEXT_XSCALE, 0x0e0001c0, 0x0f300fff, "wacc%22-23w%c\t%12-15g, %16-19g"},
 307   {ARM_CEXT_XSCALE, 0x0e000180, 0x0f000ff0, "wadd%20-23w%c\t%12-15g, %16-19g, %0-3g"},
 308   {ARM_CEXT_XSCALE, 0x0e000020, 0x0f800ff0, "waligni%c\t%12-15g, %16-19g, %0-3g, #%20-22d"},
 309   {ARM_CEXT_XSCALE, 0x0e800020, 0x0fc00ff0, "walignr%20-21d%c\t%12-15g, %16-19g, %0-3g"},
 310   {ARM_CEXT_XSCALE, 0x0e200000, 0x0fe00ff0, "wand%20'n%c\t%12-15g, %16-19g, %0-3g"},
 311   {ARM_CEXT_XSCALE, 0x0e800000, 0x0fa00ff0, "wavg2%22?hb%20'r%c\t%12-15g, %16-19g, %0-3g"},
 312   {ARM_CEXT_XSCALE, 0x0e000060, 0x0f300ff0, "wcmpeq%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 313   {ARM_CEXT_XSCALE, 0x0e100060, 0x0f100ff0, "wcmpgt%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 314   {ARM_CEXT_XSCALE, 0xfc100100, 0xfe500f00, "wldrw\t%12-15G, %A"},
 315   {ARM_CEXT_XSCALE, 0x0c100000, 0x0e100e00, "wldr%L%c\t%12-15g, %l"},
 316   {ARM_CEXT_XSCALE, 0x0e400100, 0x0fc00ff0, "wmac%21?su%20'z%c\t%12-15g, %16-19g, %0-3g"},
 317   {ARM_CEXT_XSCALE, 0x0e800100, 0x0fd00ff0, "wmadd%21?su%c\t%12-15g, %16-19g, %0-3g"},
 318   {ARM_CEXT_XSCALE, 0x0e000160, 0x0f100ff0, "wmax%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 319   {ARM_CEXT_XSCALE, 0x0e100160, 0x0f100ff0, "wmin%21?su%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 320   {ARM_CEXT_XSCALE, 0x0e000100, 0x0fc00ff0, "wmul%21?su%20?ml%c\t%12-15g, %16-19g, %0-3g"},
 321   {ARM_CEXT_XSCALE, 0x0e000000, 0x0ff00ff0, "wor%c\t%12-15g, %16-19g, %0-3g"},
 322   {ARM_CEXT_XSCALE, 0x0e000080, 0x0f000ff0, "wpack%20-23w%c\t%12-15g, %16-19g, %0-3g"},
 323   {ARM_CEXT_XSCALE, 0x0e300040, 0x0f300ff0, "wror%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
 324   {ARM_CEXT_XSCALE, 0x0e300148, 0x0f300ffc, "wror%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
 325   {ARM_CEXT_XSCALE, 0x0e000120, 0x0fa00ff0, "wsad%22?hb%20'z%c\t%12-15g, %16-19g, %0-3g"},
 326   {ARM_CEXT_XSCALE, 0x0e0001e0, 0x0f000ff0, "wshufh%c\t%12-15g, %16-19g, #%Z"},
 327   {ARM_CEXT_XSCALE, 0x0e100040, 0x0f300ff0, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
 328   {ARM_CEXT_XSCALE, 0x0e100148, 0x0f300ffc, "wsll%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
 329   {ARM_CEXT_XSCALE, 0x0e000040, 0x0f300ff0, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
 330   {ARM_CEXT_XSCALE, 0x0e000148, 0x0f300ffc, "wsra%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
 331   {ARM_CEXT_XSCALE, 0x0e200040, 0x0f300ff0, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3g"},
 332   {ARM_CEXT_XSCALE, 0x0e200148, 0x0f300ffc, "wsrl%22-23w%8'g%c\t%12-15g, %16-19g, %0-3G"},
 333   {ARM_CEXT_XSCALE, 0xfc000100, 0xfe500f00, "wstrw\t%12-15G, %A"},
 334   {ARM_CEXT_XSCALE, 0x0c000000, 0x0e100e00, "wstr%L%c\t%12-15g, %l"},
 335   {ARM_CEXT_XSCALE, 0x0e0001a0, 0x0f000ff0, "wsub%20-23w%c\t%12-15g, %16-19g, %0-3g"},
 336   {ARM_CEXT_XSCALE, 0x0e0000c0, 0x0f100fff, "wunpckeh%21?su%22-23w%c\t%12-15g, %16-19g"},
 337   {ARM_CEXT_XSCALE, 0x0e0000e0, 0x0f100fff, "wunpckel%21?su%22-23w%c\t%12-15g, %16-19g"},
 338   {ARM_CEXT_XSCALE, 0x0e1000c0, 0x0f300ff0, "wunpckih%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 339   {ARM_CEXT_XSCALE, 0x0e1000e0, 0x0f300ff0, "wunpckil%22-23w%c\t%12-15g, %16-19g, %0-3g"},
 340   {ARM_CEXT_XSCALE, 0x0e100000, 0x0ff00ff0, "wxor%c\t%12-15g, %16-19g, %0-3g"},
 341
 342   /* V5 Instructions.  */
 343   {ARM_EXT_V5, 0xe1200070, 0xfff000f0, "bkpt\t0x%16-19X%12-15X%8-11X%0-3X"},
 344   {ARM_EXT_V5, 0xfa000000, 0xfe000000, "blx\t%B"},
 345   {ARM_EXT_V5, 0x012fff30, 0x0ffffff0, "blx%c\t%0-3r"},
 346   {ARM_EXT_V5, 0x016f0f10, 0x0fff0ff0, "clz%c\t%12-15r, %0-3r"},
 347   {ARM_EXT_V5, 0xfc100000, 0xfe100000, "ldc2%22'l\t%8-11d, cr%12-15d, %A"},
 348   {ARM_EXT_V5, 0xfc000000, 0xfe100000, "stc2%22'l\t%8-11d, cr%12-15d, %A"},
 349   {ARM_EXT_V5, 0xfe000000, 0xff000010, "cdp2\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
 350   {ARM_EXT_V5, 0xfe000010, 0xff100010, "mcr2\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
 351   {ARM_EXT_V5, 0xfe100010, 0xff100010, "mrc2\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
 352
 353   /* V5E "El Segundo" Instructions.  */
 354   {ARM_EXT_V5E, 0x000000d0, 0x0e1000f0, "ldr%cd\t%12-15r, %s"},
 355   {ARM_EXT_V5E, 0x000000f0, 0x0e1000f0, "str%cd\t%12-15r, %s"},
 356   {ARM_EXT_V5E, 0xf450f000, 0xfc70f000, "pld\t%a"},
 357   {ARM_EXT_V5ExP, 0x01000080, 0x0ff000f0, "smlabb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 358   {ARM_EXT_V5ExP, 0x010000a0, 0x0ff000f0, "smlatb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 359   {ARM_EXT_V5ExP, 0x010000c0, 0x0ff000f0, "smlabt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 360   {ARM_EXT_V5ExP, 0x010000e0, 0x0ff000f0, "smlatt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 361
 362   {ARM_EXT_V5ExP, 0x01200080, 0x0ff000f0, "smlawb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 363   {ARM_EXT_V5ExP, 0x012000c0, 0x0ff000f0, "smlawt%c\t%16-19r, %0-3r, %8-11r, %12-15r"},
 364
 365   {ARM_EXT_V5ExP, 0x01400080, 0x0ff000f0, "smlalbb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 366   {ARM_EXT_V5ExP, 0x014000a0, 0x0ff000f0, "smlaltb%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 367   {ARM_EXT_V5ExP, 0x014000c0, 0x0ff000f0, "smlalbt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 368   {ARM_EXT_V5ExP, 0x014000e0, 0x0ff000f0, "smlaltt%c\t%12-15r, %16-19r, %0-3r, %8-11r"},
 369
 370   {ARM_EXT_V5ExP, 0x01600080, 0x0ff0f0f0, "smulbb%c\t%16-19r, %0-3r, %8-11r"},
 371   {ARM_EXT_V5ExP, 0x016000a0, 0x0ff0f0f0, "smultb%c\t%16-19r, %0-3r, %8-11r"},
 372   {ARM_EXT_V5ExP, 0x016000c0, 0x0ff0f0f0, "smulbt%c\t%16-19r, %0-3r, %8-11r"},
 373   {ARM_EXT_V5ExP, 0x016000e0, 0x0ff0f0f0, "smultt%c\t%16-19r, %0-3r, %8-11r"},
 374
 375   {ARM_EXT_V5ExP, 0x012000a0, 0x0ff0f0f0, "smulwb%c\t%16-19r, %0-3r, %8-11r"},
 376   {ARM_EXT_V5ExP, 0x012000e0, 0x0ff0f0f0, "smulwt%c\t%16-19r, %0-3r, %8-11r"},
 377
 378   {ARM_EXT_V5ExP, 0x01000050, 0x0ff00ff0,  "qadd%c\t%12-15r, %0-3r, %16-19r"},
 379   {ARM_EXT_V5ExP, 0x01400050, 0x0ff00ff0, "qdadd%c\t%12-15r, %0-3r, %16-19r"},
 380   {ARM_EXT_V5ExP, 0x01200050, 0x0ff00ff0,  "qsub%c\t%12-15r, %0-3r, %16-19r"},
 381   {ARM_EXT_V5ExP, 0x01600050, 0x0ff00ff0, "qdsub%c\t%12-15r, %0-3r, %16-19r"},
 382
 383   /* ARM Instructions.  */
 384   {ARM_EXT_V1, 0x00000090, 0x0e100090, "str%c%6's%5?hb\t%12-15r, %s"},
 385   {ARM_EXT_V1, 0x00100090, 0x0e100090, "ldr%c%6's%5?hb\t%12-15r, %s"},
 386   {ARM_EXT_V1, 0x00000000, 0x0de00000, "and%c%20's\t%12-15r, %16-19r, %o"},
 387   {ARM_EXT_V1, 0x00200000, 0x0de00000, "eor%c%20's\t%12-15r, %16-19r, %o"},
 388   {ARM_EXT_V1, 0x00400000, 0x0de00000, "sub%c%20's\t%12-15r, %16-19r, %o"},
 389   {ARM_EXT_V1, 0x00600000, 0x0de00000, "rsb%c%20's\t%12-15r, %16-19r, %o"},
 390   {ARM_EXT_V1, 0x00800000, 0x0de00000, "add%c%20's\t%12-15r, %16-19r, %o"},
 391   {ARM_EXT_V1, 0x00a00000, 0x0de00000, "adc%c%20's\t%12-15r, %16-19r, %o"},
 392   {ARM_EXT_V1, 0x00c00000, 0x0de00000, "sbc%c%20's\t%12-15r, %16-19r, %o"},
 393   {ARM_EXT_V1, 0x00e00000, 0x0de00000, "rsc%c%20's\t%12-15r, %16-19r, %o"},
 394   {ARM_EXT_V3, 0x0120f000, 0x0db0f000, "msr%c\t%22?SCPSR%C, %o"},
 395   {ARM_EXT_V3, 0x010f0000, 0x0fbf0fff, "mrs%c\t%12-15r, %22?SCPSR"},
 396   {ARM_EXT_V1, 0x01000000, 0x0de00000, "tst%c%p\t%16-19r, %o"},
 397   {ARM_EXT_V1, 0x01200000, 0x0de00000, "teq%c%p\t%16-19r, %o"},
 398   {ARM_EXT_V1, 0x01400000, 0x0de00000, "cmp%c%p\t%16-19r, %o"},
 399   {ARM_EXT_V1, 0x01600000, 0x0de00000, "cmn%c%p\t%16-19r, %o"},
 400   {ARM_EXT_V1, 0x01800000, 0x0de00000, "orr%c%20's\t%12-15r, %16-19r, %o"},
 401   {ARM_EXT_V1, 0x01a00000, 0x0de00000, "mov%c%20's\t%12-15r, %o"},
 402   {ARM_EXT_V1, 0x01c00000, 0x0de00000, "bic%c%20's\t%12-15r, %16-19r, %o"},
 403   {ARM_EXT_V1, 0x01e00000, 0x0de00000, "mvn%c%20's\t%12-15r, %o"},
 404   {ARM_EXT_V1, 0x04000000, 0x0e100000, "str%c%22'b%t\t%12-15r, %a"},
 405   {ARM_EXT_V1, 0x06000000, 0x0e100ff0, "str%c%22'b%t\t%12-15r, %a"},
 406   {ARM_EXT_V1, 0x04000000, 0x0c100010, "str%c%22'b%t\t%12-15r, %a"},
 407   {ARM_EXT_V1, 0x06000010, 0x0e000010, "undefined"},
 408   {ARM_EXT_V1, 0x04100000, 0x0c100000, "ldr%c%22'b%t\t%12-15r, %a"},
 409   {ARM_EXT_V1, 0x08000000, 0x0e100000, "stm%c%23?id%24?ba\t%16-19r%21'!, %m%22'^"},
 410   {ARM_EXT_V1, 0x08100000, 0x0e100000, "ldm%c%23?id%24?ba\t%16-19r%21'!, %m%22'^"},
 411   {ARM_EXT_V1, 0x0a000000, 0x0e000000, "b%24'l%c\t%b"},
 412   {ARM_EXT_V1, 0x0f000000, 0x0f000000, "swi%c\t%0-23x"},
 413
 414   /* Floating point coprocessor (FPA) instructions */
 415   {FPU_FPA_EXT_V1, 0x0e000100, 0x0ff08f10, "adf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 416   {FPU_FPA_EXT_V1, 0x0e100100, 0x0ff08f10, "muf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 417   {FPU_FPA_EXT_V1, 0x0e200100, 0x0ff08f10, "suf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 418   {FPU_FPA_EXT_V1, 0x0e300100, 0x0ff08f10, "rsf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 419   {FPU_FPA_EXT_V1, 0x0e400100, 0x0ff08f10, "dvf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 420   {FPU_FPA_EXT_V1, 0x0e500100, 0x0ff08f10, "rdf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 421   {FPU_FPA_EXT_V1, 0x0e600100, 0x0ff08f10, "pow%c%P%R\t%12-14f, %16-18f, %0-3f"},
 422   {FPU_FPA_EXT_V1, 0x0e700100, 0x0ff08f10, "rpw%c%P%R\t%12-14f, %16-18f, %0-3f"},
 423   {FPU_FPA_EXT_V1, 0x0e800100, 0x0ff08f10, "rmf%c%P%R\t%12-14f, %16-18f, %0-3f"},
 424   {FPU_FPA_EXT_V1, 0x0e900100, 0x0ff08f10, "fml%c%P%R\t%12-14f, %16-18f, %0-3f"},
 425   {FPU_FPA_EXT_V1, 0x0ea00100, 0x0ff08f10, "fdv%c%P%R\t%12-14f, %16-18f, %0-3f"},
 426   {FPU_FPA_EXT_V1, 0x0eb00100, 0x0ff08f10, "frd%c%P%R\t%12-14f, %16-18f, %0-3f"},
 427   {FPU_FPA_EXT_V1, 0x0ec00100, 0x0ff08f10, "pol%c%P%R\t%12-14f, %16-18f, %0-3f"},
 428   {FPU_FPA_EXT_V1, 0x0e008100, 0x0ff08f10, "mvf%c%P%R\t%12-14f, %0-3f"},
 429   {FPU_FPA_EXT_V1, 0x0e108100, 0x0ff08f10, "mnf%c%P%R\t%12-14f, %0-3f"},
 430   {FPU_FPA_EXT_V1, 0x0e208100, 0x0ff08f10, "abs%c%P%R\t%12-14f, %0-3f"},
 431   {FPU_FPA_EXT_V1, 0x0e308100, 0x0ff08f10, "rnd%c%P%R\t%12-14f, %0-3f"},
 432   {FPU_FPA_EXT_V1, 0x0e408100, 0x0ff08f10, "sqt%c%P%R\t%12-14f, %0-3f"},
 433   {FPU_FPA_EXT_V1, 0x0e508100, 0x0ff08f10, "log%c%P%R\t%12-14f, %0-3f"},
 434   {FPU_FPA_EXT_V1, 0x0e608100, 0x0ff08f10, "lgn%c%P%R\t%12-14f, %0-3f"},
 435   {FPU_FPA_EXT_V1, 0x0e708100, 0x0ff08f10, "exp%c%P%R\t%12-14f, %0-3f"},
 436   {FPU_FPA_EXT_V1, 0x0e808100, 0x0ff08f10, "sin%c%P%R\t%12-14f, %0-3f"},
 437   {FPU_FPA_EXT_V1, 0x0e908100, 0x0ff08f10, "cos%c%P%R\t%12-14f, %0-3f"},
 438   {FPU_FPA_EXT_V1, 0x0ea08100, 0x0ff08f10, "tan%c%P%R\t%12-14f, %0-3f"},
 439   {FPU_FPA_EXT_V1, 0x0eb08100, 0x0ff08f10, "asn%c%P%R\t%12-14f, %0-3f"},
 440   {FPU_FPA_EXT_V1, 0x0ec08100, 0x0ff08f10, "acs%c%P%R\t%12-14f, %0-3f"},
 441   {FPU_FPA_EXT_V1, 0x0ed08100, 0x0ff08f10, "atn%c%P%R\t%12-14f, %0-3f"},
 442   {FPU_FPA_EXT_V1, 0x0ee08100, 0x0ff08f10, "urd%c%P%R\t%12-14f, %0-3f"},
 443   {FPU_FPA_EXT_V1, 0x0ef08100, 0x0ff08f10, "nrm%c%P%R\t%12-14f, %0-3f"},
 444   {FPU_FPA_EXT_V1, 0x0e000110, 0x0ff00f1f, "flt%c%P%R\t%16-18f, %12-15r"},
 445   {FPU_FPA_EXT_V1, 0x0e100110, 0x0fff0f98, "fix%c%R\t%12-15r, %0-2f"},
 446   {FPU_FPA_EXT_V1, 0x0e200110, 0x0fff0fff, "wfs%c\t%12-15r"},
 447   {FPU_FPA_EXT_V1, 0x0e300110, 0x0fff0fff, "rfs%c\t%12-15r"},
 448   {FPU_FPA_EXT_V1, 0x0e400110, 0x0fff0fff, "wfc%c\t%12-15r"},
 449   {FPU_FPA_EXT_V1, 0x0e500110, 0x0fff0fff, "rfc%c\t%12-15r"},
 450   {FPU_FPA_EXT_V1, 0x0e90f110, 0x0ff8fff0, "cmf%c\t%16-18f, %0-3f"},
 451   {FPU_FPA_EXT_V1, 0x0eb0f110, 0x0ff8fff0, "cnf%c\t%16-18f, %0-3f"},
 452   {FPU_FPA_EXT_V1, 0x0ed0f110, 0x0ff8fff0, "cmfe%c\t%16-18f, %0-3f"},
 453   {FPU_FPA_EXT_V1, 0x0ef0f110, 0x0ff8fff0, "cnfe%c\t%16-18f, %0-3f"},
 454   {FPU_FPA_EXT_V1, 0x0c000100, 0x0e100f00, "stf%c%Q\t%12-14f, %A"},
 455   {FPU_FPA_EXT_V1, 0x0c100100, 0x0e100f00, "ldf%c%Q\t%12-14f, %A"},
 456   {FPU_FPA_EXT_V2, 0x0c000200, 0x0e100f00, "sfm%c\t%12-14f, %F, %A"},
 457   {FPU_FPA_EXT_V2, 0x0c100200, 0x0e100f00, "lfm%c\t%12-14f, %F, %A"},
 458
 459   /* Floating point coprocessor (VFP) instructions */
 460   {FPU_VFP_EXT_V1, 0x0eb00bc0, 0x0fff0ff0, "fabsd%c\t%1z, %0z"},
 461   {FPU_VFP_EXT_V1xD, 0x0eb00ac0, 0x0fbf0fd0, "fabss%c\t%1y, %0y"},
 462   {FPU_VFP_EXT_V1, 0x0e300b00, 0x0ff00ff0, "faddd%c\t%1z, %2z, %0z"},
 463   {FPU_VFP_EXT_V1xD, 0x0e300a00, 0x0fb00f50, "fadds%c\t%1y, %2y, %0y"},
 464   {FPU_VFP_EXT_V1, 0x0eb40b40, 0x0fff0f70, "fcmp%7'ed%c\t%1z, %0z"},
 465   {FPU_VFP_EXT_V1xD, 0x0eb40a40, 0x0fbf0f50, "fcmp%7'es%c\t%1y, %0y"},
 466   {FPU_VFP_EXT_V1, 0x0eb50b40, 0x0fff0f70, "fcmp%7'ezd%c\t%1z"},
 467   {FPU_VFP_EXT_V1xD, 0x0eb50a40, 0x0fbf0f70, "fcmp%7'ezs%c\t%1y"},
 468   {FPU_VFP_EXT_V1, 0x0eb00b40, 0x0fff0ff0, "fcpyd%c\t%1z, %0z"},
 469   {FPU_VFP_EXT_V1xD, 0x0eb00a40, 0x0fbf0fd0, "fcpys%c\t%1y, %0y"},
 470   {FPU_VFP_EXT_V1, 0x0eb70ac0, 0x0fff0fd0, "fcvtds%c\t%1z, %0y"},
 471   {FPU_VFP_EXT_V1, 0x0eb70bc0, 0x0fbf0ff0, "fcvtsd%c\t%1y, %0z"},
 472   {FPU_VFP_EXT_V1, 0x0e800b00, 0x0ff00ff0, "fdivd%c\t%1z, %2z, %0z"},
 473   {FPU_VFP_EXT_V1xD, 0x0e800a00, 0x0fb00f50, "fdivs%c\t%1y, %2y, %0y"},
 474   {FPU_VFP_EXT_V1, 0x0d100b00, 0x0f700f00, "fldd%c\t%1z, %A"},
 475   {FPU_VFP_EXT_V1xD, 0x0c900b00, 0x0fd00f00, "fldmia%0?xd%c\t%16-19r%21'!, %3z"},
 476   {FPU_VFP_EXT_V1xD, 0x0d300b00, 0x0ff00f00, "fldmdb%0?xd%c\t%16-19r!, %3z"},
 477   {FPU_VFP_EXT_V1xD, 0x0d100a00, 0x0f300f00, "flds%c\t%1y, %A"},
 478   {FPU_VFP_EXT_V1xD, 0x0c900a00, 0x0f900f00, "fldmias%c\t%16-19r%21'!, %3y"},
 479   {FPU_VFP_EXT_V1xD, 0x0d300a00, 0x0fb00f00, "fldmdbs%c\t%16-19r!, %3y"},
 480   {FPU_VFP_EXT_V1, 0x0e000b00, 0x0ff00ff0, "fmacd%c\t%1z, %2z, %0z"},
 481   {FPU_VFP_EXT_V1xD, 0x0e000a00, 0x0fb00f50, "fmacs%c\t%1y, %2y, %0y"},
 482   {FPU_VFP_EXT_V1, 0x0e200b10, 0x0ff00fff, "fmdhr%c\t%2z, %12-15r"},
 483   {FPU_VFP_EXT_V1, 0x0e000b10, 0x0ff00fff, "fmdlr%c\t%2z, %12-15r"},
 484   {FPU_VFP_EXT_V2, 0x0c400b10, 0x0ff00ff0, "fmdrr%c\t%0z, %12-15r, %16-19r"},
 485   {FPU_VFP_EXT_V1, 0x0e300b10, 0x0ff00fff, "fmrdh%c\t%12-15r, %2z"},
 486   {FPU_VFP_EXT_V1, 0x0e100b10, 0x0ff00fff, "fmrdl%c\t%12-15r, %2z"},
 487   {FPU_VFP_EXT_V1, 0x0c500b10, 0x0ff00ff0, "fmrrd%c\t%12-15r, %16-19r, %0z"},
 488   {FPU_VFP_EXT_V2, 0x0c500a10, 0x0ff00fd0, "fmrrs%c\t%12-15r, %16-19r, %4y"},
 489   {FPU_VFP_EXT_V1xD, 0x0e100a10, 0x0ff00f7f, "fmrs%c\t%12-15r, %2y"},
 490   {FPU_VFP_EXT_V1xD, 0x0ef1fa10, 0x0fffffff, "fmstat%c"},
 491   {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpsid"},
 492   {FPU_VFP_EXT_V1xD, 0x0ef10a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpscr"},
 493   {FPU_VFP_EXT_V1xD, 0x0ef80a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpexc"},
 494   {FPU_VFP_EXT_V1xD, 0x0ef90a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst\t@ Impl def"},
 495   {FPU_VFP_EXT_V1xD, 0x0efa0a10, 0x0fff0fff, "fmrx%c\t%12-15r, fpinst2\t@ Impl def"},
 496   {FPU_VFP_EXT_V1xD, 0x0ef00a10, 0x0ff00fff, "fmrx%c\t%12-15r, <impl def 0x%16-19x>"},
 497   {FPU_VFP_EXT_V1, 0x0e100b00, 0x0ff00ff0, "fmscd%c\t%1z, %2z, %0z"},
 498   {FPU_VFP_EXT_V1xD, 0x0e100a00, 0x0fb00f50, "fmscs%c\t%1y, %2y, %0y"},
 499   {FPU_VFP_EXT_V1xD, 0x0e000a10, 0x0ff00f7f, "fmsr%c\t%2y, %12-15r"},
 500   {FPU_VFP_EXT_V2, 0x0c400a10, 0x0ff00fd0, "fmsrr%c\t%12-15r, %16-19r, %4y"},
 501   {FPU_VFP_EXT_V1, 0x0e200b00, 0x0ff00ff0, "fmuld%c\t%1z, %2z, %0z"},
 502   {FPU_VFP_EXT_V1xD, 0x0e200a00, 0x0fb00f50, "fmuls%c\t%1y, %2y, %0y"},
 503   {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0fff0fff, "fmxr%c\tfpsid, %12-15r"},
 504   {FPU_VFP_EXT_V1xD, 0x0ee10a10, 0x0fff0fff, "fmxr%c\tfpscr, %12-15r"},
 505   {FPU_VFP_EXT_V1xD, 0x0ee80a10, 0x0fff0fff, "fmxr%c\tfpexc, %12-15r"},
 506   {FPU_VFP_EXT_V1xD, 0x0ee90a10, 0x0fff0fff, "fmxr%c\tfpinst, %12-15r\t@ Impl def"},
 507   {FPU_VFP_EXT_V1xD, 0x0eea0a10, 0x0fff0fff, "fmxr%c\tfpinst2, %12-15r\t@ Impl def"},
 508   {FPU_VFP_EXT_V1xD, 0x0ee00a10, 0x0ff00fff, "fmxr%c\t<impl def 0x%16-19x>, %12-15r"},
 509   {FPU_VFP_EXT_V1, 0x0eb10b40, 0x0fff0ff0, "fnegd%c\t%1z, %0z"},
 510   {FPU_VFP_EXT_V1xD, 0x0eb10a40, 0x0fbf0fd0, "fnegs%c\t%1y, %0y"},
 511   {FPU_VFP_EXT_V1, 0x0e000b40, 0x0ff00ff0, "fnmacd%c\t%1z, %2z, %0z"},
 512   {FPU_VFP_EXT_V1xD, 0x0e000a40, 0x0fb00f50, "fnmacs%c\t%1y, %2y, %0y"},
 513   {FPU_VFP_EXT_V1, 0x0e100b40, 0x0ff00ff0, "fnmscd%c\t%1z, %2z, %0z"},
 514   {FPU_VFP_EXT_V1xD, 0x0e100a40, 0x0fb00f50, "fnmscs%c\t%1y, %2y, %0y"},
 515   {FPU_VFP_EXT_V1, 0x0e200b40, 0x0ff00ff0, "fnmuld%c\t%1z, %2z, %0z"},
 516   {FPU_VFP_EXT_V1xD, 0x0e200a40, 0x0fb00f50, "fnmuls%c\t%1y, %2y, %0y"},
 517   {FPU_VFP_EXT_V1, 0x0eb80bc0, 0x0fff0fd0, "fsitod%c\t%1z, %0y"},
 518   {FPU_VFP_EXT_V1xD, 0x0eb80ac0, 0x0fbf0fd0, "fsitos%c\t%1y, %0y"},
 519   {FPU_VFP_EXT_V1, 0x0eb10bc0, 0x0fff0ff0, "fsqrtd%c\t%1z, %0z"},
 520   {FPU_VFP_EXT_V1xD, 0x0eb10ac0, 0x0fbf0fd0, "fsqrts%c\t%1y, %0y"},
 521   {FPU_VFP_EXT_V1, 0x0d000b00, 0x0f700f00, "fstd%c\t%1z, %A"},
 522   {FPU_VFP_EXT_V1xD, 0x0c800b00, 0x0fd00f00, "fstmia%0?xd%c\t%16-19r%21'!, %3z"},
 523   {FPU_VFP_EXT_V1xD, 0x0d200b00, 0x0ff00f00, "fstmdb%0?xd%c\t%16-19r!, %3z"},
 524   {FPU_VFP_EXT_V1xD, 0x0d000a00, 0x0f300f00, "fsts%c\t%1y, %A"},
 525   {FPU_VFP_EXT_V1xD, 0x0c800a00, 0x0f900f00, "fstmias%c\t%16-19r%21'!, %3y"},
 526   {FPU_VFP_EXT_V1xD, 0x0d200a00, 0x0fb00f00, "fstmdbs%c\t%16-19r!, %3y"},
 527   {FPU_VFP_EXT_V1, 0x0e300b40, 0x0ff00ff0, "fsubd%c\t%1z, %2z, %0z"},
 528   {FPU_VFP_EXT_V1xD, 0x0e300a40, 0x0fb00f50, "fsubs%c\t%1y, %2y, %0y"},
 529   {FPU_VFP_EXT_V1, 0x0ebc0b40, 0x0fbe0f70, "fto%16?sui%7'zd%c\t%1y, %0z"},
 530   {FPU_VFP_EXT_V1xD, 0x0ebc0a40, 0x0fbe0f50, "fto%16?sui%7'zs%c\t%1y, %0y"},
 531   {FPU_VFP_EXT_V1, 0x0eb80b40, 0x0fff0fd0, "fuitod%c\t%1z, %0y"},
 532   {FPU_VFP_EXT_V1xD, 0x0eb80a40, 0x0fbf0fd0, "fuitos%c\t%1y, %0y"},
 533
 534   /* Cirrus coprocessor instructions.  */
 535   {ARM_CEXT_MAVERICK, 0x0d100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
 536   {ARM_CEXT_MAVERICK, 0x0c100400, 0x0f500f00, "cfldrs%c\tmvf%12-15d, %A"},
 537   {ARM_CEXT_MAVERICK, 0x0d500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
 538   {ARM_CEXT_MAVERICK, 0x0c500400, 0x0f500f00, "cfldrd%c\tmvd%12-15d, %A"},
 539   {ARM_CEXT_MAVERICK, 0x0d100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
 540   {ARM_CEXT_MAVERICK, 0x0c100500, 0x0f500f00, "cfldr32%c\tmvfx%12-15d, %A"},
 541   {ARM_CEXT_MAVERICK, 0x0d500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
 542   {ARM_CEXT_MAVERICK, 0x0c500500, 0x0f500f00, "cfldr64%c\tmvdx%12-15d, %A"},
 543   {ARM_CEXT_MAVERICK, 0x0d000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
 544   {ARM_CEXT_MAVERICK, 0x0c000400, 0x0f500f00, "cfstrs%c\tmvf%12-15d, %A"},
 545   {ARM_CEXT_MAVERICK, 0x0d400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
 546   {ARM_CEXT_MAVERICK, 0x0c400400, 0x0f500f00, "cfstrd%c\tmvd%12-15d, %A"},
 547   {ARM_CEXT_MAVERICK, 0x0d000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
 548   {ARM_CEXT_MAVERICK, 0x0c000500, 0x0f500f00, "cfstr32%c\tmvfx%12-15d, %A"},
 549   {ARM_CEXT_MAVERICK, 0x0d400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
 550   {ARM_CEXT_MAVERICK, 0x0c400500, 0x0f500f00, "cfstr64%c\tmvdx%12-15d, %A"},
 551   {ARM_CEXT_MAVERICK, 0x0e000450, 0x0ff00ff0, "cfmvsr%c\tmvf%16-19d, %12-15r"},
 552   {ARM_CEXT_MAVERICK, 0x0e100450, 0x0ff00ff0, "cfmvrs%c\t%12-15r, mvf%16-19d"},
 553   {ARM_CEXT_MAVERICK, 0x0e000410, 0x0ff00ff0, "cfmvdlr%c\tmvd%16-19d, %12-15r"},
 554   {ARM_CEXT_MAVERICK, 0x0e100410, 0x0ff00ff0, "cfmvrdl%c\t%12-15r, mvd%16-19d"},
 555   {ARM_CEXT_MAVERICK, 0x0e000430, 0x0ff00ff0, "cfmvdhr%c\tmvd%16-19d, %12-15r"},
 556   {ARM_CEXT_MAVERICK, 0x0e100430, 0x0ff00fff, "cfmvrdh%c\t%12-15r, mvd%16-19d"},
 557   {ARM_CEXT_MAVERICK, 0x0e000510, 0x0ff00fff, "cfmv64lr%c\tmvdx%16-19d, %12-15r"},
 558   {ARM_CEXT_MAVERICK, 0x0e100510, 0x0ff00fff, "cfmvr64l%c\t%12-15r, mvdx%16-19d"},
 559   {ARM_CEXT_MAVERICK, 0x0e000530, 0x0ff00fff, "cfmv64hr%c\tmvdx%16-19d, %12-15r"},
 560   {ARM_CEXT_MAVERICK, 0x0e100530, 0x0ff00fff, "cfmvr64h%c\t%12-15r, mvdx%16-19d"},
 561   {ARM_CEXT_MAVERICK, 0x0e200440, 0x0ff00fff, "cfmval32%c\tmvax%12-15d, mvfx%16-19d"},
 562   {ARM_CEXT_MAVERICK, 0x0e100440, 0x0ff00fff, "cfmv32al%c\tmvfx%12-15d, mvax%16-19d"},
 563   {ARM_CEXT_MAVERICK, 0x0e200460, 0x0ff00fff, "cfmvam32%c\tmvax%12-15d, mvfx%16-19d"},
 564   {ARM_CEXT_MAVERICK, 0x0e100460, 0x0ff00fff, "cfmv32am%c\tmvfx%12-15d, mvax%16-19d"},
 565   {ARM_CEXT_MAVERICK, 0x0e200480, 0x0ff00fff, "cfmvah32%c\tmvax%12-15d, mvfx%16-19d"},
 566   {ARM_CEXT_MAVERICK, 0x0e100480, 0x0ff00fff, "cfmv32ah%c\tmvfx%12-15d, mvax%16-19d"},
 567   {ARM_CEXT_MAVERICK, 0x0e2004a0, 0x0ff00fff, "cfmva32%c\tmvax%12-15d, mvfx%16-19d"},
 568   {ARM_CEXT_MAVERICK, 0x0e1004a0, 0x0ff00fff, "cfmv32a%c\tmvfx%12-15d, mvax%16-19d"},
 569   {ARM_CEXT_MAVERICK, 0x0e2004c0, 0x0ff00fff, "cfmva64%c\tmvax%12-15d, mvdx%16-19d"},
 570   {ARM_CEXT_MAVERICK, 0x0e1004c0, 0x0ff00fff, "cfmv64a%c\tmvdx%12-15d, mvax%16-19d"},
 571   {ARM_CEXT_MAVERICK, 0x0e2004e0, 0x0fff0fff, "cfmvsc32%c\tdspsc, mvdx%12-15d"},
 572   {ARM_CEXT_MAVERICK, 0x0e1004e0, 0x0fff0fff, "cfmv32sc%c\tmvdx%12-15d, dspsc"},
 573   {ARM_CEXT_MAVERICK, 0x0e000400, 0x0ff00fff, "cfcpys%c\tmvf%12-15d, mvf%16-19d"},
 574   {ARM_CEXT_MAVERICK, 0x0e000420, 0x0ff00fff, "cfcpyd%c\tmvd%12-15d, mvd%16-19d"},
 575   {ARM_CEXT_MAVERICK, 0x0e000460, 0x0ff00fff, "cfcvtsd%c\tmvd%12-15d, mvf%16-19d"},
 576   {ARM_CEXT_MAVERICK, 0x0e000440, 0x0ff00fff, "cfcvtds%c\tmvf%12-15d, mvd%16-19d"},
 577   {ARM_CEXT_MAVERICK, 0x0e000480, 0x0ff00fff, "cfcvt32s%c\tmvf%12-15d, mvfx%16-19d"},
 578   {ARM_CEXT_MAVERICK, 0x0e0004a0, 0x0ff00fff, "cfcvt32d%c\tmvd%12-15d, mvfx%16-19d"},
 579   {ARM_CEXT_MAVERICK, 0x0e0004c0, 0x0ff00fff, "cfcvt64s%c\tmvf%12-15d, mvdx%16-19d"},
 580   {ARM_CEXT_MAVERICK, 0x0e0004e0, 0x0ff00fff, "cfcvt64d%c\tmvd%12-15d, mvdx%16-19d"},
 581   {ARM_CEXT_MAVERICK, 0x0e100580, 0x0ff00fff, "cfcvts32%c\tmvfx%12-15d, mvf%16-19d"},
 582   {ARM_CEXT_MAVERICK, 0x0e1005a0, 0x0ff00fff, "cfcvtd32%c\tmvfx%12-15d, mvd%16-19d"},
 583   {ARM_CEXT_MAVERICK, 0x0e1005c0, 0x0ff00fff, "cftruncs32%c\tmvfx%12-15d, mvf%16-19d"},
 584   {ARM_CEXT_MAVERICK, 0x0e1005e0, 0x0ff00fff, "cftruncd32%c\tmvfx%12-15d, mvd%16-19d"},
 585   {ARM_CEXT_MAVERICK, 0x0e000550, 0x0ff00ff0, "cfrshl32%c\tmvfx%16-19d, mvfx%0-3d, %12-15r"},
 586   {ARM_CEXT_MAVERICK, 0x0e000570, 0x0ff00ff0, "cfrshl64%c\tmvdx%16-19d, mvdx%0-3d, %12-15r"},
 587   {ARM_CEXT_MAVERICK, 0x0e000500, 0x0ff00f00, "cfsh32%c\tmvfx%12-15d, mvfx%16-19d, #%I"},
 588   {ARM_CEXT_MAVERICK, 0x0e200500, 0x0ff00f00, "cfsh64%c\tmvdx%12-15d, mvdx%16-19d, #%I"},
 589   {ARM_CEXT_MAVERICK, 0x0e100490, 0x0ff00ff0, "cfcmps%c\t%12-15r, mvf%16-19d, mvf%0-3d"},
 590   {ARM_CEXT_MAVERICK, 0x0e1004b0, 0x0ff00ff0, "cfcmpd%c\t%12-15r, mvd%16-19d, mvd%0-3d"},
 591   {ARM_CEXT_MAVERICK, 0x0e100590, 0x0ff00ff0, "cfcmp32%c\t%12-15r, mvfx%16-19d, mvfx%0-3d"},
 592   {ARM_CEXT_MAVERICK, 0x0e1005b0, 0x0ff00ff0, "cfcmp64%c\t%12-15r, mvdx%16-19d, mvdx%0-3d"},
 593   {ARM_CEXT_MAVERICK, 0x0e300400, 0x0ff00fff, "cfabss%c\tmvf%12-15d, mvf%16-19d"},
 594   {ARM_CEXT_MAVERICK, 0x0e300420, 0x0ff00fff, "cfabsd%c\tmvd%12-15d, mvd%16-19d"},
 595   {ARM_CEXT_MAVERICK, 0x0e300440, 0x0ff00fff, "cfnegs%c\tmvf%12-15d, mvf%16-19d"},
 596   {ARM_CEXT_MAVERICK, 0x0e300460, 0x0ff00fff, "cfnegd%c\tmvd%12-15d, mvd%16-19d"},
 597   {ARM_CEXT_MAVERICK, 0x0e300480, 0x0ff00ff0, "cfadds%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
 598   {ARM_CEXT_MAVERICK, 0x0e3004a0, 0x0ff00ff0, "cfaddd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
 599   {ARM_CEXT_MAVERICK, 0x0e3004c0, 0x0ff00ff0, "cfsubs%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
 600   {ARM_CEXT_MAVERICK, 0x0e3004e0, 0x0ff00ff0, "cfsubd%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
 601   {ARM_CEXT_MAVERICK, 0x0e100400, 0x0ff00ff0, "cfmuls%c\tmvf%12-15d, mvf%16-19d, mvf%0-3d"},
 602   {ARM_CEXT_MAVERICK, 0x0e100420, 0x0ff00ff0, "cfmuld%c\tmvd%12-15d, mvd%16-19d, mvd%0-3d"},
 603   {ARM_CEXT_MAVERICK, 0x0e300500, 0x0ff00fff, "cfabs32%c\tmvfx%12-15d, mvfx%16-19d"},
 604   {ARM_CEXT_MAVERICK, 0x0e300520, 0x0ff00fff, "cfabs64%c\tmvdx%12-15d, mvdx%16-19d"},
 605   {ARM_CEXT_MAVERICK, 0x0e300540, 0x0ff00fff, "cfneg32%c\tmvfx%12-15d, mvfx%16-19d"},
 606   {ARM_CEXT_MAVERICK, 0x0e300560, 0x0ff00fff, "cfneg64%c\tmvdx%12-15d, mvdx%16-19d"},
 607   {ARM_CEXT_MAVERICK, 0x0e300580, 0x0ff00ff0, "cfadd32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 608   {ARM_CEXT_MAVERICK, 0x0e3005a0, 0x0ff00ff0, "cfadd64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
 609   {ARM_CEXT_MAVERICK, 0x0e3005c0, 0x0ff00ff0, "cfsub32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 610   {ARM_CEXT_MAVERICK, 0x0e3005e0, 0x0ff00ff0, "cfsub64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
 611   {ARM_CEXT_MAVERICK, 0x0e100500, 0x0ff00ff0, "cfmul32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 612   {ARM_CEXT_MAVERICK, 0x0e100520, 0x0ff00ff0, "cfmul64%c\tmvdx%12-15d, mvdx%16-19d, mvdx%0-3d"},
 613   {ARM_CEXT_MAVERICK, 0x0e100540, 0x0ff00ff0, "cfmac32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 614   {ARM_CEXT_MAVERICK, 0x0e100560, 0x0ff00ff0, "cfmsc32%c\tmvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 615   {ARM_CEXT_MAVERICK, 0x0e000600, 0x0ff00f00, "cfmadd32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 616   {ARM_CEXT_MAVERICK, 0x0e100600, 0x0ff00f00, "cfmsub32%c\tmvax%5-7d, mvfx%12-15d, mvfx%16-19d, mvfx%0-3d"},
 617   {ARM_CEXT_MAVERICK, 0x0e200600, 0x0ff00f00, "cfmadda32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
 618   {ARM_CEXT_MAVERICK, 0x0e300600, 0x0ff00f00, "cfmsuba32%c\tmvax%5-7d, mvax%12-15d, mvfx%16-19d, mvfx%0-3d"},
 619
 620   /* Generic coprocessor instructions */
 621   {ARM_EXT_V2, 0x0c400000, 0x0ff00000, "mcrr%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 622   {ARM_EXT_V2, 0x0c500000, 0x0ff00000, "mrrc%c\t%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 623   {ARM_EXT_V2, 0x0e000000, 0x0f000010, "cdp%c\t%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, {%5-7d}"},
 624   {ARM_EXT_V2, 0x0e100010, 0x0f100010, "mrc%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
 625   {ARM_EXT_V2, 0x0e000010, 0x0f100010, "mcr%c\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},
 626   {ARM_EXT_V2, 0x0c000000, 0x0e100000, "stc%c%22'l\t%8-11d, cr%12-15d, %A"},
 627   {ARM_EXT_V2, 0x0c100000, 0x0e100000, "ldc%c%22'l\t%8-11d, cr%12-15d, %A"},
 628
 629   /* The rest.  */
 630   {ARM_EXT_V1, 0x00000000, 0x00000000, "undefined instruction %0-31x"},
 631   {0, 0x00000000, 0x00000000, 0}
 632 };
 633
 634 /* print_insn_thumb16 recognizes the following format control codes:
 635
 636    %S                   print Thumb register (bits 3..5 as high number if bit 6 set)
 637    %D                   print Thumb register (bits 0..2 as high number if bit 7 set)
 638    %<bitfield>I         print bitfield as a signed decimal
 639                                 (top bit of range being the sign bit)
 640    %N                   print Thumb register mask (with LR)
 641    %O                   print Thumb register mask (with PC)
 642    %M                   print Thumb register mask
 643    %b                   print CZB's 6-bit unsigned branch destination
 644    %s                   print Thumb right-shift immediate (6..10; 0 == 32).
 645    %<bitfield>r         print bitfield as an ARM register
 646    %<bitfield>d         print bitfield as a decimal
 647    %<bitfield>H         print (bitfield * 2) as a decimal
 648    %<bitfield>W         print (bitfield * 4) as a decimal
 649    %<bitfield>a         print (bitfield * 4) as a pc-rel offset + decoded symbol
 650    %<bitfield>B         print Thumb branch destination (signed displacement)
 651    %<bitfield>c         print bitfield as a condition code
 652    %<bitnum>'c          print specified char iff bit is one
 653    %<bitnum>?ab         print a if bit is one else print b.  */
 654
 655 static const struct opcode16 thumb_opcodes[] =
 656 {
 657   /* Thumb instructions.  */
 658
 659   /* ARM V6K no-argument instructions.  */
 660   {ARM_EXT_V6K, 0xbf00, 0xffff, "nop"},
 661   {ARM_EXT_V6K, 0xbf10, 0xffff, "yield"},
 662   {ARM_EXT_V6K, 0xbf20, 0xffff, "wfe"},
 663   {ARM_EXT_V6K, 0xbf30, 0xffff, "wfi"},
 664   {ARM_EXT_V6K, 0xbf40, 0xffff, "sev"},
 665   {ARM_EXT_V6K, 0xbf00, 0xff0f, "nop\t{%4-7d}"},
 666
 667   /* ARM V6T2 instructions.  */
 668   {ARM_EXT_V6T2, 0xb900, 0xfd00, "cbnz\t%0-2r, %b"},
 669   {ARM_EXT_V6T2, 0xb100, 0xfd00, "cbz\t%0-2r, %b"},
 670   {ARM_EXT_V6T2, 0xbf08, 0xff0f, "it\t%4-7c"},
 671   {ARM_EXT_V6T2, 0xbf14, 0xff17, "it%3?te\t%4-7c"},
 672   {ARM_EXT_V6T2, 0xbf04, 0xff17, "it%3?et\t%4-7c"},
 673   {ARM_EXT_V6T2, 0xbf12, 0xff13, "it%3?te%2?te\t%4-7c"},
 674   {ARM_EXT_V6T2, 0xbf02, 0xff13, "it%3?et%2?et\t%4-7c"},
 675   {ARM_EXT_V6T2, 0xbf11, 0xff11, "it%3?te%2?te%1?te\t%4-7c"},
 676   {ARM_EXT_V6T2, 0xbf01, 0xff11, "it%3?et%2?et%1?et\t%4-7c"},
 677
 678   /* ARM V6.  */
 679   {ARM_EXT_V6, 0xb660, 0xfff8, "cpsie\t%2'a%1'i%0'f"},
 680   {ARM_EXT_V6, 0xb670, 0xfff8, "cpsid\t%2'a%1'i%0'f"},
 681   {ARM_EXT_V6, 0x4600, 0xffc0, "mov\t%0-2r, %3-5r"},
 682   {ARM_EXT_V6, 0xba00, 0xffc0, "rev\t%0-2r, %3-5r"},
 683   {ARM_EXT_V6, 0xba40, 0xffc0, "rev16\t%0-2r, %3-5r"},
 684   {ARM_EXT_V6, 0xbac0, 0xffc0, "revsh\t%0-2r, %3-5r"},
 685   {ARM_EXT_V6, 0xb650, 0xfff7, "setend\t%3?ble"},
 686   {ARM_EXT_V6, 0xb200, 0xffc0, "sxth\t%0-2r, %3-5r"},
 687   {ARM_EXT_V6, 0xb240, 0xffc0, "sxtb\t%0-2r, %3-5r"},
 688   {ARM_EXT_V6, 0xb280, 0xffc0, "uxth\t%0-2r, %3-5r"},
 689   {ARM_EXT_V6, 0xb2c0, 0xffc0, "uxtb\t%0-2r, %3-5r"},
 690
 691   /* ARM V5 ISA extends Thumb.  */
 692   {ARM_EXT_V5T, 0xbe00, 0xff00, "bkpt\t%0-7x"},
 693   /* This is BLX(2).  BLX(1) is a 32-bit instruction.  */
 694   {ARM_EXT_V5T, 0x4780, 0xff87, "blx\t%3-6r"},  /* note: 4 bit register number.  */
 695   /* ARM V4T ISA (Thumb v1).  */
 696   {ARM_EXT_V4T, 0x46C0, 0xFFFF, "nop\t\t\t(mov r8, r8)"},
 697   /* Format 4.  */
 698   {ARM_EXT_V4T, 0x4000, 0xFFC0, "ands\t%0-2r, %3-5r"},
 699   {ARM_EXT_V4T, 0x4040, 0xFFC0, "eors\t%0-2r, %3-5r"},
 700   {ARM_EXT_V4T, 0x4080, 0xFFC0, "lsls\t%0-2r, %3-5r"},
 701   {ARM_EXT_V4T, 0x40C0, 0xFFC0, "lsrs\t%0-2r, %3-5r"},
 702   {ARM_EXT_V4T, 0x4100, 0xFFC0, "asrs\t%0-2r, %3-5r"},
 703   {ARM_EXT_V4T, 0x4140, 0xFFC0, "adcs\t%0-2r, %3-5r"},
 704   {ARM_EXT_V4T, 0x4180, 0xFFC0, "sbcs\t%0-2r, %3-5r"},
 705   {ARM_EXT_V4T, 0x41C0, 0xFFC0, "rors\t%0-2r, %3-5r"},
 706   {ARM_EXT_V4T, 0x4200, 0xFFC0, "tst\t%0-2r, %3-5r"},
 707   {ARM_EXT_V4T, 0x4240, 0xFFC0, "negs\t%0-2r, %3-5r"},
 708   {ARM_EXT_V4T, 0x4280, 0xFFC0, "cmp\t%0-2r, %3-5r"},
 709   {ARM_EXT_V4T, 0x42C0, 0xFFC0, "cmn\t%0-2r, %3-5r"},
 710   {ARM_EXT_V4T, 0x4300, 0xFFC0, "orrs\t%0-2r, %3-5r"},
 711   {ARM_EXT_V4T, 0x4340, 0xFFC0, "muls\t%0-2r, %3-5r"},
 712   {ARM_EXT_V4T, 0x4380, 0xFFC0, "bics\t%0-2r, %3-5r"},
 713   {ARM_EXT_V4T, 0x43C0, 0xFFC0, "mvns\t%0-2r, %3-5r"},
 714   /* format 13 */
 715   {ARM_EXT_V4T, 0xB000, 0xFF80, "add\tsp, #%0-6W"},
 716   {ARM_EXT_V4T, 0xB080, 0xFF80, "sub\tsp, #%0-6W"},
 717   /* format 5 */
 718   {ARM_EXT_V4T, 0x4700, 0xFF80, "bx\t%S"},
 719   {ARM_EXT_V4T, 0x4400, 0xFF00, "add\t%D, %S"},
 720   {ARM_EXT_V4T, 0x4500, 0xFF00, "cmp\t%D, %S"},
 721   {ARM_EXT_V4T, 0x4600, 0xFF00, "mov\t%D, %S"},
 722   /* format 14 */
 723   {ARM_EXT_V4T, 0xB400, 0xFE00, "push\t%N"},
 724   {ARM_EXT_V4T, 0xBC00, 0xFE00, "pop\t%O"},
 725   /* format 2 */
 726   {ARM_EXT_V4T, 0x1800, 0xFE00, "adds\t%0-2r, %3-5r, %6-8r"},
 727   {ARM_EXT_V4T, 0x1A00, 0xFE00, "subs\t%0-2r, %3-5r, %6-8r"},
 728   {ARM_EXT_V4T, 0x1C00, 0xFE00, "adds\t%0-2r, %3-5r, #%6-8d"},
 729   {ARM_EXT_V4T, 0x1E00, 0xFE00, "subs\t%0-2r, %3-5r, #%6-8d"},
 730   /* format 8 */
 731   {ARM_EXT_V4T, 0x5200, 0xFE00, "strh\t%0-2r, [%3-5r, %6-8r]"},
 732   {ARM_EXT_V4T, 0x5A00, 0xFE00, "ldrh\t%0-2r, [%3-5r, %6-8r]"},
 733   {ARM_EXT_V4T, 0x5600, 0xF600, "ldrs%11?hb\t%0-2r, [%3-5r, %6-8r]"},
 734   /* format 7 */
 735   {ARM_EXT_V4T, 0x5000, 0xFA00, "str%10'b\t%0-2r, [%3-5r, %6-8r]"},
 736   {ARM_EXT_V4T, 0x5800, 0xFA00, "ldr%10'b\t%0-2r, [%3-5r, %6-8r]"},
 737   /* format 1 */
 738   {ARM_EXT_V4T, 0x0000, 0xF800, "lsls\t%0-2r, %3-5r, #%6-10d"},
 739   {ARM_EXT_V4T, 0x0800, 0xF800, "lsrs\t%0-2r, %3-5r, %s"},
 740   {ARM_EXT_V4T, 0x1000, 0xF800, "asrs\t%0-2r, %3-5r, %s"},
 741   /* format 3 */
 742   {ARM_EXT_V4T, 0x2000, 0xF800, "movs\t%8-10r, #%0-7d"},
 743   {ARM_EXT_V4T, 0x2800, 0xF800, "cmp\t%8-10r, #%0-7d"},
 744   {ARM_EXT_V4T, 0x3000, 0xF800, "adds\t%8-10r, #%0-7d"},
 745   {ARM_EXT_V4T, 0x3800, 0xF800, "subs\t%8-10r, #%0-7d"},
 746   /* format 6 */
 747   {ARM_EXT_V4T, 0x4800, 0xF800, "ldr\t%8-10r, [pc, #%0-7W]\t(%0-7a)"},  /* TODO: Disassemble PC relative "LDR rD,=<symbolic>" */
 748   /* format 9 */
 749   {ARM_EXT_V4T, 0x6000, 0xF800, "str\t%0-2r, [%3-5r, #%6-10W]"},
 750   {ARM_EXT_V4T, 0x6800, 0xF800, "ldr\t%0-2r, [%3-5r, #%6-10W]"},
 751   {ARM_EXT_V4T, 0x7000, 0xF800, "strb\t%0-2r, [%3-5r, #%6-10d]"},
 752   {ARM_EXT_V4T, 0x7800, 0xF800, "ldrb\t%0-2r, [%3-5r, #%6-10d]"},
 753   /* format 10 */
 754   {ARM_EXT_V4T, 0x8000, 0xF800, "strh\t%0-2r, [%3-5r, #%6-10H]"},
 755   {ARM_EXT_V4T, 0x8800, 0xF800, "ldrh\t%0-2r, [%3-5r, #%6-10H]"},
 756   /* format 11 */
 757   {ARM_EXT_V4T, 0x9000, 0xF800, "str\t%8-10r, [sp, #%0-7W]"},
 758   {ARM_EXT_V4T, 0x9800, 0xF800, "ldr\t%8-10r, [sp, #%0-7W]"},
 759   /* format 12 */
 760   {ARM_EXT_V4T, 0xA000, 0xF800, "add\t%8-10r, pc, #%0-7W\t(adr %8-10r,%0-7a)"},
 761   {ARM_EXT_V4T, 0xA800, 0xF800, "add\t%8-10r, sp, #%0-7W"},
 762   /* format 15 */
 763   {ARM_EXT_V4T, 0xC000, 0xF800, "stmia\t%8-10r!, %M"},
 764   {ARM_EXT_V4T, 0xC800, 0xF800, "ldmia\t%8-10r!, %M"},
 765   /* format 17 */
 766   {ARM_EXT_V4T, 0xDF00, 0xFF00, "swi\t%0-7d"},
 767   /* format 16 */
 768   {ARM_EXT_V4T, 0xD000, 0xF000, "b%8-11c.n\t%0-7B"},
 769   /* format 18 */
 770   {ARM_EXT_V4T, 0xE000, 0xF800, "b.n\t%0-10B"},
 771
 772   /* The E800 .. FFFF range is unconditionally redirected to the
 773      32-bit table, because even in pre-V6T2 ISAs, BL and BLX(1) pairs
 774      are processed via that table.  Thus, we can never encounter a
 775      bare "second half of BL/BLX(1)" instruction here.  */
 776   {ARM_EXT_V1,  0x0000, 0x0000, "undefined"},
 777   {0, 0, 0, 0}
 778 };
 779
 780 /* Thumb32 opcodes use the same table structure as the ARM opcodes.
 781    We adopt the convention that hw1 is the high 16 bits of .value and
 782    .mask, hw2 the low 16 bits.
 783
 784    print_insn_thumb32 recognizes the following format control codes:
 785
 786        %%               %
 787
 788        %I               print a 12-bit immediate from hw1[10],hw2[14:12,7:0]
 789        %M               print a modified 12-bit immediate (same location)
 790        %J               print a 16-bit immediate from hw1[3:0,10],hw2[14:12,7:0]
 791        %K               print a 16-bit immediate from hw2[3:0],hw1[3:0],hw2[11:4]
 792        %S               print a possibly-shifted Rm
 793
 794        %a               print the address of a plain load/store
 795        %A               print the address of a coprocessor load/store
 796        %w               print the width and signedness of a core load/store
 797        %m               print register mask for ldm/stm
 798
 799        %E               print the lsb and width fields of a bfc/bfi instruction
 800        %F               print the lsb and width fields of a sbfx/ubfx instruction
 801        %b               print a conditional branch offset
 802        %B               print an unconditional branch offset
 803        %s               print the shift field of an SSAT instruction
 804        %R               print the rotation field of an SXT instruction
 805
 806        %<bitfield>d     print bitfield in decimal
 807        %<bitfield>W     print bitfield*4 in decimal
 808        %<bitfield>r     print bitfield as an ARM register
 809        %<bitfield>c     print bitfield as a condition code
 810
 811        %<bitnum>'c      print "c" iff bit is one
 812        %<bitnum>`c      print "c" iff bit is zero
 813        %<bitnum>?ab     print "a" if bit is one, else "b"
 814
 815    With one exception at the bottom (done because BL and BLX(1) need
 816    to come dead last), this table was machine-sorted first in
 817    decreasing order of number of bits set in the mask, then in
 818    increasing numeric order of mask, then in increasing numeric order
 819    of opcode.  This order is not the clearest for a human reader, but
 820    is guaranteed never to catch a special-case bit pattern with a more
 821    general mask, which is important, because this instruction encoding
 822    makes heavy use of special-case bit patterns.  */
 823 static const struct opcode32 thumb32_opcodes[] =
 824 {
 825   /* Instructions defined in the basic V6T2 set.  */
 826   {ARM_EXT_V6T2, 0xf3af8000, 0xffffffff, "nop.w"},
 827   {ARM_EXT_V6T2, 0xf3af8001, 0xffffffff, "yield.w"},
 828   {ARM_EXT_V6T2, 0xf3af8002, 0xffffffff, "wfe.w"},
 829   {ARM_EXT_V6T2, 0xf3af8003, 0xffffffff, "wfi.w"},
 830   {ARM_EXT_V6T2, 0xf3af9004, 0xffffffff, "sev.w"},
 831   {ARM_EXT_V6T2, 0xf3af8000, 0xffffff00, "nop.w\t{%0-7d}"},
 832
 833   {ARM_EXT_V6T2, 0xf3bf8f2f, 0xffffffff, "clrex"},
 834   {ARM_EXT_V6T2, 0xf3af8400, 0xffffff1f, "cpsie.w\t%7'a%6'i%5'f"},
 835   {ARM_EXT_V6T2, 0xf3af8600, 0xffffff1f, "cpsid.w\t%7'a%6'i%5'f"},
 836   {ARM_EXT_V6T2, 0xf3c08f00, 0xfff0ffff, "bxj\t%16-19r"},
 837   {ARM_EXT_V6T2, 0xe810c000, 0xffd0ffff, "rfedb\t%16-19r%21'!"},
 838   {ARM_EXT_V6T2, 0xe990c000, 0xffd0ffff, "rfeia\t%16-19r%21'!"},
 839   {ARM_EXT_V6T2, 0xf3ef8000, 0xffeff0ff, "mrs\t%8-11r, %20?CSPSR"},
 840   {ARM_EXT_V6T2, 0xf3af8100, 0xffffffe0, "cps\t#%0-4d"},
 841   {ARM_EXT_V6T2, 0xe8d0f000, 0xfff0fff0, "tbb\t[%16-19r, %0-3r]"},
 842   {ARM_EXT_V6T2, 0xe8d0f010, 0xfff0fff0, "tbh\t[%16-19r, %0-3r, lsl #1]"},
 843   {ARM_EXT_V6T2, 0xf3af8500, 0xffffff00, "cpsie\t%7'a%6'i%5'f, #%0-4d"},
 844   {ARM_EXT_V6T2, 0xf3af8700, 0xffffff00, "cpsid\t%7'a%6'i%5'f, #%0-4d"},
 845   {ARM_EXT_V6T2, 0xf3de8f00, 0xffffff00, "subs\tpc, lr, #%0-7d"},
 846   {ARM_EXT_V6T2, 0xf3808000, 0xffe0f0ff, "msr\t%20?CSPSR_%8'c%9'x%10's%11'f, %16-19r"},
 847   {ARM_EXT_V6T2, 0xe8500f00, 0xfff00fff, "ldrex\t%12-15r, [%16-19r]"},
 848   {ARM_EXT_V6T2, 0xe8d00f4f, 0xfff00fef, "ldrex%4?hb\t%12-15r, [%16-19r]"},
 849   {ARM_EXT_V6T2, 0xe800c000, 0xffd0ffe0, "srsdb\t#%0-4d%21'!"},
 850   {ARM_EXT_V6T2, 0xe980c000, 0xffd0ffe0, "srsia\t#%0-4d%21'!"},
 851   {ARM_EXT_V6T2, 0xfa0ff080, 0xfffff0c0, "sxth.w\t%8-11r, %0-3r%R"},
 852   {ARM_EXT_V6T2, 0xfa1ff080, 0xfffff0c0, "uxth.w\t%8-11r, %0-3r%R"},
 853   {ARM_EXT_V6T2, 0xfa2ff080, 0xfffff0c0, "sxtb16\t%8-11r, %0-3r%R"},
 854   {ARM_EXT_V6T2, 0xfa3ff080, 0xfffff0c0, "uxtb16\t%8-11r, %0-3r%R"},
 855   {ARM_EXT_V6T2, 0xfa4ff080, 0xfffff0c0, "sxtb.w\t%8-11r, %0-3r%R"},
 856   {ARM_EXT_V6T2, 0xfa5ff080, 0xfffff0c0, "uxtb.w\t%8-11r, %0-3r%R"},
 857   {ARM_EXT_V6T2, 0xe8400000, 0xfff000ff, "strex\t%8-11r, %12-15r, [%16-19r]"},
 858   {ARM_EXT_V6T2, 0xe8d0007f, 0xfff000ff, "ldrexd\t%12-15r, %8-11r, [%16-19r]"},
 859   {ARM_EXT_V6T2, 0xfa80f000, 0xfff0f0f0, "sadd8\t%8-11r, %16-19r, %0-3r"},
 860   {ARM_EXT_V6T2, 0xfa80f010, 0xfff0f0f0, "qadd8\t%8-11r, %16-19r, %0-3r"},
 861   {ARM_EXT_V6T2, 0xfa80f020, 0xfff0f0f0, "shadd8\t%8-11r, %16-19r, %0-3r"},
 862   {ARM_EXT_V6T2, 0xfa80f040, 0xfff0f0f0, "uadd8\t%8-11r, %16-19r, %0-3r"},
 863   {ARM_EXT_V6T2, 0xfa80f050, 0xfff0f0f0, "uqadd8\t%8-11r, %16-19r, %0-3r"},
 864   {ARM_EXT_V6T2, 0xfa80f060, 0xfff0f0f0, "uhadd8\t%8-11r, %16-19r, %0-3r"},
 865   {ARM_EXT_V6T2, 0xfa80f080, 0xfff0f0f0, "qadd\t%8-11r, %0-3r, %16-19r"},
 866   {ARM_EXT_V6T2, 0xfa80f090, 0xfff0f0f0, "qdadd\t%8-11r, %0-3r, %16-19r"},
 867   {ARM_EXT_V6T2, 0xfa80f0a0, 0xfff0f0f0, "qsub\t%8-11r, %0-3r, %16-19r"},
 868   {ARM_EXT_V6T2, 0xfa80f0b0, 0xfff0f0f0, "qdsub\t%8-11r, %0-3r, %16-19r"},
 869   {ARM_EXT_V6T2, 0xfa90f000, 0xfff0f0f0, "sadd16\t%8-11r, %16-19r, %0-3r"},
 870   {ARM_EXT_V6T2, 0xfa90f010, 0xfff0f0f0, "qadd16\t%8-11r, %16-19r, %0-3r"},
 871   {ARM_EXT_V6T2, 0xfa90f020, 0xfff0f0f0, "shadd16\t%8-11r, %16-19r, %0-3r"},
 872   {ARM_EXT_V6T2, 0xfa90f040, 0xfff0f0f0, "uadd16\t%8-11r, %16-19r, %0-3r"},
 873   {ARM_EXT_V6T2, 0xfa90f050, 0xfff0f0f0, "uqadd16\t%8-11r, %16-19r, %0-3r"},
 874   {ARM_EXT_V6T2, 0xfa90f060, 0xfff0f0f0, "uhadd16\t%8-11r, %16-19r, %0-3r"},
 875   {ARM_EXT_V6T2, 0xfa90f080, 0xfff0f0f0, "rev.w\t%8-11r, %16-19r"},
 876   {ARM_EXT_V6T2, 0xfa90f090, 0xfff0f0f0, "rev16.w\t%8-11r, %16-19r"},
 877   {ARM_EXT_V6T2, 0xfa90f0a0, 0xfff0f0f0, "rbit\t%8-11r, %16-19r"},
 878   {ARM_EXT_V6T2, 0xfa90f0b0, 0xfff0f0f0, "revsh.w\t%8-11r, %16-19r"},
 879   {ARM_EXT_V6T2, 0xfaa0f000, 0xfff0f0f0, "saddsubx\t%8-11r, %16-19r, %0-3r"},
 880   {ARM_EXT_V6T2, 0xfaa0f010, 0xfff0f0f0, "qaddsubx\t%8-11r, %16-19r, %0-3r"},
 881   {ARM_EXT_V6T2, 0xfaa0f020, 0xfff0f0f0, "shaddsubx\t%8-11r, %16-19r, %0-3r"},
 882   {ARM_EXT_V6T2, 0xfaa0f040, 0xfff0f0f0, "uaddsubx\t%8-11r, %16-19r, %0-3r"},
 883   {ARM_EXT_V6T2, 0xfaa0f050, 0xfff0f0f0, "uqaddsubx\t%8-11r, %16-19r, %0-3r"},
 884   {ARM_EXT_V6T2, 0xfaa0f060, 0xfff0f0f0, "uhaddsubx\t%8-11r, %16-19r, %0-3r"},
 885   {ARM_EXT_V6T2, 0xfaa0f080, 0xfff0f0f0, "sel\t%8-11r, %16-19r, %0-3r"},
 886   {ARM_EXT_V6T2, 0xfab0f080, 0xfff0f0f0, "clz\t%8-11r, %16-19r"},
 887   {ARM_EXT_V6T2, 0xfac0f000, 0xfff0f0f0, "ssub8\t%8-11r, %16-19r, %0-3r"},
 888   {ARM_EXT_V6T2, 0xfac0f010, 0xfff0f0f0, "qsub8\t%8-11r, %16-19r, %0-3r"},
 889   {ARM_EXT_V6T2, 0xfac0f020, 0xfff0f0f0, "shsub8\t%8-11r, %16-19r, %0-3r"},
 890   {ARM_EXT_V6T2, 0xfac0f040, 0xfff0f0f0, "usub8\t%8-11r, %16-19r, %0-3r"},
 891   {ARM_EXT_V6T2, 0xfac0f050, 0xfff0f0f0, "uqsub8\t%8-11r, %16-19r, %0-3r"},
 892   {ARM_EXT_V6T2, 0xfac0f060, 0xfff0f0f0, "uhsub8\t%8-11r, %16-19r, %0-3r"},
 893   {ARM_EXT_V6T2, 0xfad0f000, 0xfff0f0f0, "ssub16\t%8-11r, %16-19r, %0-3r"},
 894   {ARM_EXT_V6T2, 0xfad0f010, 0xfff0f0f0, "qsub16\t%8-11r, %16-19r, %0-3r"},
 895   {ARM_EXT_V6T2, 0xfad0f020, 0xfff0f0f0, "shsub16\t%8-11r, %16-19r, %0-3r"},
 896   {ARM_EXT_V6T2, 0xfad0f040, 0xfff0f0f0, "usub16\t%8-11r, %16-19r, %0-3r"},
 897   {ARM_EXT_V6T2, 0xfad0f050, 0xfff0f0f0, "uqsub16\t%8-11r, %16-19r, %0-3r"},
 898   {ARM_EXT_V6T2, 0xfad0f060, 0xfff0f0f0, "uhsub16\t%8-11r, %16-19r, %0-3r"},
 899   {ARM_EXT_V6T2, 0xfae0f000, 0xfff0f0f0, "ssubaddx\t%8-11r, %16-19r, %0-3r"},
 900   {ARM_EXT_V6T2, 0xfae0f010, 0xfff0f0f0, "qsubaddx\t%8-11r, %16-19r, %0-3r"},
 901   {ARM_EXT_V6T2, 0xfae0f020, 0xfff0f0f0, "shsubaddx\t%8-11r, %16-19r, %0-3r"},
 902   {ARM_EXT_V6T2, 0xfae0f040, 0xfff0f0f0, "usubaddx\t%8-11r, %16-19r, %0-3r"},
 903   {ARM_EXT_V6T2, 0xfae0f050, 0xfff0f0f0, "uqsubaddx\t%8-11r, %16-19r, %0-3r"},
 904   {ARM_EXT_V6T2, 0xfae0f060, 0xfff0f0f0, "uhsubaddx\t%8-11r, %16-19r, %0-3r"},
 905   {ARM_EXT_V6T2, 0xfb00f000, 0xfff0f0f0, "mul.w\t%8-11r, %16-19r, %0-3r"},
 906   {ARM_EXT_V6T2, 0xfb70f000, 0xfff0f0f0, "usad8\t%8-11r, %16-19r, %0-3r"},
 907   {ARM_EXT_V6T2, 0xfa00f000, 0xffe0f0f0, "lsl%20's.w\t%8-11r, %16-19r, %0-3r"},
 908   {ARM_EXT_V6T2, 0xfa20f000, 0xffe0f0f0, "lsr%20's.w\t%8-11r, %16-19r, %0-3r"},
 909   {ARM_EXT_V6T2, 0xfa40f000, 0xffe0f0f0, "asr%20's.w\t%8-11r, %16-19r, %0-3r"},
 910   {ARM_EXT_V6T2, 0xfa60f000, 0xffe0f0f0, "ror%20's.w\t%8-11r, %16-19r, %0-3r"},
 911   {ARM_EXT_V6T2, 0xe8c00f40, 0xfff00fe0, "strex%4?hb\t%0-3r, %12-15r, [%16-19r]"},
 912   {ARM_EXT_V6T2, 0xf3200000, 0xfff0f0e0, "ssat16\t%8-11r, #%0-4d, %16-19r"},
 913   {ARM_EXT_V6T2, 0xf3a00000, 0xfff0f0e0, "usat16\t%8-11r, #%0-4d, %16-19r"},
 914   {ARM_EXT_V6T2, 0xfb20f000, 0xfff0f0e0, "smuad%4'x\t%8-11r, %16-19r, %0-3r"},
 915   {ARM_EXT_V6T2, 0xfb30f000, 0xfff0f0e0, "smulw%4?tb\t%8-11r, %16-19r, %0-3r"},
 916   {ARM_EXT_V6T2, 0xfb40f000, 0xfff0f0e0, "smusd%4'x\t%8-11r, %16-19r, %0-3r"},
 917   {ARM_EXT_V6T2, 0xfb50f000, 0xfff0f0e0, "smmul%4'r\t%8-11r, %16-19r, %0-3r"},
 918   {ARM_EXT_V6T2, 0xfa00f080, 0xfff0f0c0, "sxtah\t%8-11r, %16-19r, %0-3r%R"},
 919   {ARM_EXT_V6T2, 0xfa10f080, 0xfff0f0c0, "uxtah\t%8-11r, %16-19r, %0-3r%R"},
 920   {ARM_EXT_V6T2, 0xfa20f080, 0xfff0f0c0, "sxtab16\t%8-11r, %16-19r, %0-3r%R"},
 921   {ARM_EXT_V6T2, 0xfa30f080, 0xfff0f0c0, "uxtab16\t%8-11r, %16-19r, %0-3r%R"},
 922   {ARM_EXT_V6T2, 0xfa40f080, 0xfff0f0c0, "sxtab\t%8-11r, %16-19r, %0-3r%R"},
 923   {ARM_EXT_V6T2, 0xfa50f080, 0xfff0f0c0, "uxtab\t%8-11r, %16-19r, %0-3r%R"},
 924   {ARM_EXT_V6T2, 0xfb10f000, 0xfff0f0c0, "smul%5?tb%4?tb\t%8-11r, %16-19r, %0-3r"},
 925   {ARM_EXT_V6T2, 0xf36f0000, 0xffff8020, "bfc\t%8-11r, %E"},
 926   {ARM_EXT_V6T2, 0xea100f00, 0xfff08f00, "tst.w\t%16-19r, %S"},
 927   {ARM_EXT_V6T2, 0xea900f00, 0xfff08f00, "teq\t%16-19r, %S"},
 928   {ARM_EXT_V6T2, 0xeb100f00, 0xfff08f00, "cmn.w\t%16-19r, %S"},
 929   {ARM_EXT_V6T2, 0xebb00f00, 0xfff08f00, "cmp.w\t%16-19r, %S"},
 930   {ARM_EXT_V6T2, 0xf0100f00, 0xfbf08f00, "tst.w\t%16-19r, %M"},
 931   {ARM_EXT_V6T2, 0xf0900f00, 0xfbf08f00, "teq\t%16-19r, %M"},
 932   {ARM_EXT_V6T2, 0xf1100f00, 0xfbf08f00, "cmn.w\t%16-19r, %M"},
 933   {ARM_EXT_V6T2, 0xf1b00f00, 0xfbf08f00, "cmp.w\t%16-19r, %M"},
 934   {ARM_EXT_V6T2, 0xea4f0000, 0xffef8000, "mov%20's.w\t%8-11r, %S"},
 935   {ARM_EXT_V6T2, 0xea6f0000, 0xffef8000, "mvn%20's.w\t%8-11r, %S"},
 936   {ARM_EXT_V6T2, 0xe8c00070, 0xfff000f0, "strexd\t%0-3r, %12-15r, %8-11r, [%16-19r]"},
 937   {ARM_EXT_V6T2, 0xfb000000, 0xfff000f0, "mla\t%8-11r, %16-19r, %0-3r, %12-15r"},
 938   {ARM_EXT_V6T2, 0xfb000010, 0xfff000f0, "mls\t%8-11r, %16-19r, %0-3r, %12-15r"},
 939   {ARM_EXT_V6T2, 0xfb700000, 0xfff000f0, "usada8\t%8-11r, %16-19r, %0-3r, %12-15r"},
 940   {ARM_EXT_V6T2, 0xfb800000, 0xfff000f0, "smull\t%12-15r, %8-11r, %16-19r, %0-3r"},
 941   {ARM_EXT_V6T2, 0xfba00000, 0xfff000f0, "umull\t%12-15r, %8-11r, %16-19r, %0-3r"},
 942   {ARM_EXT_V6T2, 0xfbc00000, 0xfff000f0, "smlal\t%12-15r, %8-11r, %16-19r, %0-3r"},
 943   {ARM_EXT_V6T2, 0xfbe00000, 0xfff000f0, "umlal\t%12-15r, %8-11r, %16-19r, %0-3r"},
 944   {ARM_EXT_V6T2, 0xfbe00060, 0xfff000f0, "umaal\t%12-15r, %8-11r, %16-19r, %0-3r"},
 945   {ARM_EXT_V6T2, 0xe8500f00, 0xfff00f00, "ldrex\t%12-15r, [%16-19r, #%0-7W]"},
 946   {ARM_EXT_V6T2, 0xf7f08000, 0xfff0f000, "smi\t%K"},
 947   {ARM_EXT_V6T2, 0xf04f0000, 0xfbef8000, "mov%20's.w\t%8-11r, %M"},
 948   {ARM_EXT_V6T2, 0xf06f0000, 0xfbef8000, "mvn%20's.w\t%8-11r, %M"},
 949   {ARM_EXT_V6T2, 0xf810f000, 0xff70f000, "pld\t%a"},
 950   {ARM_EXT_V6T2, 0xfb200000, 0xfff000e0, "smlad%4'x\t%8-11r, %16-19r, %0-3r, %12-15r"},
 951   {ARM_EXT_V6T2, 0xfb300000, 0xfff000e0, "smlaw%4?tb\t%8-11r, %16-19r, %0-3r, %12-15r"},
 952   {ARM_EXT_V6T2, 0xfb400000, 0xfff000e0, "smlsd%4'x\t%8-11r, %16-19r, %0-3r, %12-15r"},
 953   {ARM_EXT_V6T2, 0xfb500000, 0xfff000e0, "smmla%4'r\t%8-11r, %16-19r, %0-3r, %12-15r"},
 954   {ARM_EXT_V6T2, 0xfb600000, 0xfff000e0, "smmls%4'r\t%8-11r, %16-19r, %0-3r, %12-15r"},
 955   {ARM_EXT_V6T2, 0xfbc000c0, 0xfff000e0, "smlald%4'x\t%12-15r, %8-11r, %16-19r, %0-3r"},
 956   {ARM_EXT_V6T2, 0xfbd000c0, 0xfff000e0, "smlsld%4'x\t%12-15r, %8-11r, %16-19r, %0-3r"},
 957   {ARM_EXT_V6T2, 0xeac00000, 0xfff08030, "pkhbt\t%8-11r, %16-19r, %S"},
 958   {ARM_EXT_V6T2, 0xeac00020, 0xfff08030, "pkhtb\t%8-11r, %16-19r, %S"},
 959   {ARM_EXT_V6T2, 0xf3400000, 0xfff08020, "sbfx\t%8-11r, %16-19r, %F"},
 960   {ARM_EXT_V6T2, 0xf3c00000, 0xfff08020, "ubfx\t%8-11r, %16-19r, %F"},
 961   {ARM_EXT_V6T2, 0xf8000e00, 0xff900f00, "str%wt\t%12-15r, %a"},
 962   {ARM_EXT_V6T2, 0xfb100000, 0xfff000c0, "smla%5?tb%4?tb\t%8-11r, %16-19r, %0-3r, %12-15r"},
 963   {ARM_EXT_V6T2, 0xfbc00080, 0xfff000c0, "smlal%5?tb%4?tb\t%12-15r, %8-11r, %16-19r, %0-3r"},
 964   {ARM_EXT_V6T2, 0xf3600000, 0xfff08020, "bfi\t%8-11r, %16-19r, %E"},
 965   {ARM_EXT_V6T2, 0xf8100e00, 0xfe900f00, "ldr%wt\t%12-15r, %a"},
 966   {ARM_EXT_V6T2, 0xf3000000, 0xffd08020, "ssat\t%8-11r, #%0-4d, %16-19r%s"},
 967   {ARM_EXT_V6T2, 0xf3800000, 0xffd08020, "usat\t%8-11r, #%0-4d, %16-19r%s"},
 968   {ARM_EXT_V6T2, 0xee000010, 0xef1000f0, "mcr%28'2\tp%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d"},
 969   {ARM_EXT_V6T2, 0xee100010, 0xef1000f0, "mrc%28'2\tp%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d"},
 970   {ARM_EXT_V6T2, 0xf2000000, 0xfbf08000, "addw\t%8-11r, %16-19r, %I"},
 971   {ARM_EXT_V6T2, 0xf2400000, 0xfbf08000, "movw\t%8-11r, %J"},
 972   {ARM_EXT_V6T2, 0xf2a00000, 0xfbf08000, "subw\t%8-11r, %16-19r, %I"},
 973   {ARM_EXT_V6T2, 0xf2c00000, 0xfbf08000, "movt\t%8-11r, %J"},
 974   {ARM_EXT_V6T2, 0xea000000, 0xffe08000, "and%20's.w\t%8-11r, %16-19r, %S"},
 975   {ARM_EXT_V6T2, 0xea200000, 0xffe08000, "bic%20's.w\t%8-11r, %16-19r, %S"},
 976   {ARM_EXT_V6T2, 0xea400000, 0xffe08000, "orr%20's.w\t%8-11r, %16-19r, %S"},
 977   {ARM_EXT_V6T2, 0xea600000, 0xffe08000, "orn%20's\t%8-11r, %16-19r, %S"},
 978   {ARM_EXT_V6T2, 0xea800000, 0xffe08000, "eor%20's.w\t%8-11r, %16-19r, %S"},
 979   {ARM_EXT_V6T2, 0xeb000000, 0xffe08000, "add%20's.w\t%8-11r, %16-19r, %S"},
 980   {ARM_EXT_V6T2, 0xeb400000, 0xffe08000, "adc%20's.w\t%8-11r, %16-19r, %S"},
 981   {ARM_EXT_V6T2, 0xeb600000, 0xffe08000, "sbc%20's.w\t%8-11r, %16-19r, %S"},
 982   {ARM_EXT_V6T2, 0xeba00000, 0xffe08000, "sub%20's.w\t%8-11r, %16-19r, %S"},
 983   {ARM_EXT_V6T2, 0xebc00000, 0xffe08000, "rsb%20's\t%8-11r, %16-19r, %S"},
 984   {ARM_EXT_V6T2, 0xe8400000, 0xfff00000, "strex\t%8-11r, %12-15r, [%16-19r, #%0-7W]"},
 985   {ARM_EXT_V6T2, 0xee000000, 0xef0000f0, "cdp%28'2\tp%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d"},
 986   {ARM_EXT_V6T2, 0xec400000, 0xeff00000, "mcrr%28'2\tp%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 987   {ARM_EXT_V6T2, 0xec500000, 0xeff00000, "mrrc%28'2\tp%8-11d, %4-7d, %12-15r, %16-19r, cr%0-3d"},
 988   {ARM_EXT_V6T2, 0xf0000000, 0xfbe08000, "and%20's.w\t%8-11r, %16-19r, %M"},
 989   {ARM_EXT_V6T2, 0xf0200000, 0xfbe08000, "bic%20's.w\t%8-11r, %16-19r, %M"},
 990   {ARM_EXT_V6T2, 0xf0400000, 0xfbe08000, "orr%20's.w\t%8-11r, %16-19r, %M"},
 991   {ARM_EXT_V6T2, 0xf0600000, 0xfbe08000, "orn%20's\t%8-11r, %16-19r, %M"},
 992   {ARM_EXT_V6T2, 0xf0800000, 0xfbe08000, "eor%20's.w\t%8-11r, %16-19r, %M"},
 993   {ARM_EXT_V6T2, 0xf1000000, 0xfbe08000, "add%20's.w\t%8-11r, %16-19r, %M"},
 994   {ARM_EXT_V6T2, 0xf1400000, 0xfbe08000, "adc%20's.w\t%8-11r, %16-19r, %M"},
 995   {ARM_EXT_V6T2, 0xf1600000, 0xfbe08000, "sbc%20's.w\t%8-11r, %16-19r, %M"},
 996   {ARM_EXT_V6T2, 0xf1a00000, 0xfbe08000, "sub%20's.w\t%8-11r, %16-19r, %M"},
 997   {ARM_EXT_V6T2, 0xf1c00000, 0xfbe08000, "rsb%20's\t%8-11r, %16-19r, %M"},
 998   {ARM_EXT_V6T2, 0xe8800000, 0xffd00000, "stmia.w\t%16-19r%21'!, %m"},
 999   {ARM_EXT_V6T2, 0xe8900000, 0xffd00000, "ldmia.w\t%16-19r%21'!, %m"},
1000   {ARM_EXT_V6T2, 0xe9000000, 0xffd00000, "stmdb\t%16-19r%21'!, %m"},
1001   {ARM_EXT_V6T2, 0xe9100000, 0xffd00000, "ldmdb\t%16-19r%21'!, %m"},
1002   {ARM_EXT_V6T2, 0xe9c00000, 0xffd000ff, "strd\t%12-15r, %8-11r, [%16-19r]"},
1003   {ARM_EXT_V6T2, 0xe9d00000, 0xffd000ff, "ldrd\t%12-15r, %8-11r, [%16-19r]"},
1004   {ARM_EXT_V6T2, 0xe9400000, 0xff500000, "strd\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]"},
1005   {ARM_EXT_V6T2, 0xe9500000, 0xff500000, "ldrd\t%12-15r, %8-11r, [%16-19r, #%23`-%0-7W]"},
1006   {ARM_EXT_V6T2, 0xee000010, 0xef100010, "mcr%28'2\tp%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, %5-7d"},
1007   {ARM_EXT_V6T2, 0xee100010, 0xef100010, "mrc%28'2\tp%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, %5-7d"},
1008   {ARM_EXT_V6T2, 0xf8000000, 0xff100000, "str%w.w\t%12-15r, %a"},
1009   {ARM_EXT_V6T2, 0xf8100000, 0xfe100000, "ldr%w.w\t%12-15r, %a"},
1010   {ARM_EXT_V6T2, 0xec000000, 0xee100000, "stc%28'2%22'l\tp%8-11d, cr%12-15d, %A"},
1011   {ARM_EXT_V6T2, 0xec100000, 0xee100000, "ldc%28'2%22'l\tp%8-11d, cr%12-15d, %A"},
1012   {ARM_EXT_V6T2, 0xee000000, 0xef000010, "cdp%28'2\tp%8-11d, %20-23d, cr%12-15d, cr%16-19d, cr%0-3d, %5-7d"},
1013
1014   /* Filter out Bcc with cond=E or F, which are used for other instructions.  */
1015   {ARM_EXT_V6T2, 0xf3c08000, 0xfbc0d000, "undefined (bcc, cond=0xF)"},
1016   {ARM_EXT_V6T2, 0xf3808000, 0xfbc0d000, "undefined (bcc, cond=0xE)"},
1017   {ARM_EXT_V6T2, 0xf0008000, 0xf800d000, "b%22-25c.w\t%b"},
1018   {ARM_EXT_V6T2, 0xf0009000, 0xf800d000, "b.w\t%B"},
1019
1020   /* These have been 32-bit since the invention of Thumb.  */
1021   {ARM_EXT_V4T,  0xf000c000, 0xf800d000, "blx\t%B"},
1022   {ARM_EXT_V4T,  0xf000d000, 0xf800d000, "bl\t%B"},
1023
1024   /* Fallback.  */
1025   {ARM_EXT_V1,   0x00000000, 0x00000000, "undefined"},
1026   {0, 0, 0, 0}
1027 };
1028
1029 static const char *const arm_conditional[] =
1030 {"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
1031  "hi", "ls", "ge", "lt", "gt", "le", "", "<und>"};
1032
1033 static const char *const arm_fp_const[] =
1034 {"0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0"};
1035
1036 static const char *const arm_shift[] =
1037 {"lsl", "lsr", "asr", "ror"};
1038
1039 typedef struct
1040 {
1041   const char *name;
1042   const char *description;
1043   const char *reg_names[16];
1044 }
1045 arm_regname;
1046
1047 static const arm_regname regnames[] =
1048 {
1049   { "raw" , "Select raw register names",
1050     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"}},
1051   { "gcc",  "Select register names used by GCC",
1052     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1053   { "std",  "Select register names used in ARM's ISA documentation",
1054     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "sp",  "lr",  "pc" }},
1055   { "apcs", "Select register names used in the APCS",
1056     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "sl",  "fp",  "ip",  "sp",  "lr",  "pc" }},
1057   { "atpcs", "Select register names used in the ATPCS",
1058     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "v4", "v5", "v6", "v7",  "v8",  "IP",  "SP",  "LR",  "PC" }},
1059   { "special-atpcs", "Select special register names used in the ATPCS",
1060     { "a1", "a2", "a3", "a4", "v1", "v2", "v3", "WR", "v5", "SB", "SL",  "FP",  "IP",  "SP",  "LR",  "PC" }},
1061 };
1062
1063 static const char *const iwmmxt_wwnames[] =
1064 {"b", "h", "w", "d"};
1065
1066 static const char *const iwmmxt_wwssnames[] =
1067 {"b", "bus", "b", "bss",
1068  "h", "hus", "h", "hss",
1069  "w", "wus", "w", "wss",
1070  "d", "dus", "d", "dss"
1071 };
1072
1073 static const char *const iwmmxt_regnames[] =
1074 { "wr0", "wr1", "wr2", "wr3", "wr4", "wr5", "wr6", "wr7",
1075   "wr8", "wr9", "wr10", "wr11", "wr12", "wr13", "wr14", "wr15"
1076 };
1077
1078 static const char *const iwmmxt_cregnames[] =
1079 { "wcid", "wcon", "wcssf", "wcasf", "reserved", "reserved", "reserved", "reserved",
1080   "wcgr0", "wcgr1", "wcgr2", "wcgr3", "reserved", "reserved", "reserved", "reserved"
1081 };
1082
1083 /* Default to GCC register name set.  */
1084 static unsigned int regname_selected = 1;
1085
1086 #define NUM_ARM_REGNAMES  NUM_ELEM (regnames)
1087 #define arm_regnames      regnames[regname_selected].reg_names
1088
1089 static bfd_boolean force_thumb = FALSE;
1090
1091 \f
1092 /* Functions.  */
1093 int
1094 get_arm_regname_num_options (void)
1095 {
1096   return NUM_ARM_REGNAMES;
1097 }
1098
1099 int
1100 set_arm_regname_option (int option)
1101 {
1102   int old = regname_selected;
1103   regname_selected = option;
1104   return old;
1105 }
1106
1107 int
1108 get_arm_regnames (int option, const char **setname, const char **setdescription,
1109                   const char *const **register_names)
1110 {
1111   *setname = regnames[option].name;
1112   *setdescription = regnames[option].description;
1113   *register_names = regnames[option].reg_names;
1114   return 16;
1115 }
1116
1117 static void
1118 arm_decode_shift (long given, fprintf_ftype func, void *stream)
1119 {
1120   func (stream, "%s", arm_regnames[given & 0xf]);
1121
1122   if ((given & 0xff0) != 0)
1123     {
1124       if ((given & 0x10) == 0)
1125         {
1126           int amount = (given & 0xf80) >> 7;
1127           int shift = (given & 0x60) >> 5;
1128
1129           if (amount == 0)
1130             {
1131               if (shift == 3)
1132                 {
1133                   func (stream, ", rrx");
1134                   return;
1135                 }
1136
1137               amount = 32;
1138             }
1139
1140           func (stream, ", %s #%d", arm_shift[shift], amount);
1141         }
1142       else
1143         func (stream, ", %s %s", arm_shift[(given & 0x60) >> 5],
1144               arm_regnames[(given & 0xf00) >> 8]);
1145     }
1146 }
1147
1148 /* Print one ARM instruction from PC on INFO->STREAM.  */
1149
1150 static void
1151 print_insn_arm (bfd_vma pc, struct disassemble_info *info, long given)
1152 {
1153   const struct opcode32 *insn;
1154   void *stream = info->stream;
1155   fprintf_ftype func = info->fprintf_func;
1156
1157   for (insn = arm_opcodes; insn->assembler; insn++)
1158     {
1159       if (insn->value == FIRST_IWMMXT_INSN
1160           && info->mach != bfd_mach_arm_XScale
1161           && info->mach != bfd_mach_arm_iWMMXt)
1162         insn = insn + IWMMXT_INSN_COUNT;
1163
1164       if ((given & insn->mask) == insn->value
1165           /* Special case: an instruction with all bits set in the condition field
1166              (0xFnnn_nnnn) is only matched if all those bits are set in insn->mask,
1167              or by the catchall at the end of the table.  */
1168           && ((given & 0xF0000000) != 0xF0000000
1169               || (insn->mask & 0xF0000000) == 0xF0000000
1170               || (insn->mask == 0 && insn->value == 0)))
1171         {
1172           const char *c;
1173
1174           for (c = insn->assembler; *c; c++)
1175             {
1176               if (*c == '%')
1177                 {
1178                   switch (*++c)
1179                     {
1180                     case '%':
1181                       func (stream, "%%");
1182                       break;
1183
1184                     case 'a':
1185                       if (((given & 0x000f0000) == 0x000f0000)
1186                           && ((given & 0x02000000) == 0))
1187                         {
1188                           int offset = given & 0xfff;
1189
1190                           func (stream, "[pc");
1191
1192                           if (given & 0x01000000)
1193                             {
1194                               if ((given & 0x00800000) == 0)
1195                                 offset = - offset;
1196
1197                               /* Pre-indexed.  */
1198                               func (stream, ", #%d]", offset);
1199
1200                               offset += pc + 8;
1201
1202                               /* Cope with the possibility of write-back
1203                                  being used.  Probably a very dangerous thing
1204                                  for the programmer to do, but who are we to
1205                                  argue ?  */
1206                               if (given & 0x00200000)
1207                                 func (stream, "!");
1208                             }
1209                           else
1210                             {
1211                               /* Post indexed.  */
1212                               func (stream, "], #%d", offset);
1213
1214                               /* ie ignore the offset.  */
1215                               offset = pc + 8;
1216                             }
1217
1218                           func (stream, "\t; ");
1219                           info->print_address_func (offset, info);
1220                         }
1221                       else
1222                         {
1223                           func (stream, "[%s",
1224                                 arm_regnames[(given >> 16) & 0xf]);
1225                           if ((given & 0x01000000) != 0)
1226                             {
1227                               if ((given & 0x02000000) == 0)
1228                                 {
1229                                   int offset = given & 0xfff;
1230                                   if (offset)
1231                                     func (stream, ", #%s%d",
1232                                           (((given & 0x00800000) == 0)
1233                                            ? "-" : ""), offset);
1234                                 }
1235                               else
1236                                 {
1237                                   func (stream, ", %s",
1238                                         (((given & 0x00800000) == 0)
1239                                          ? "-" : ""));
1240                                   arm_decode_shift (given, func, stream);
1241                                 }
1242
1243                               func (stream, "]%s",
1244                                     ((given & 0x00200000) != 0) ? "!" : "");
1245                             }
1246                           else
1247                             {
1248                               if ((given & 0x02000000) == 0)
1249                                 {
1250                                   int offset = given & 0xfff;
1251                                   if (offset)
1252                                     func (stream, "], #%s%d",
1253                                           (((given & 0x00800000) == 0)
1254                                            ? "-" : ""), offset);
1255                                   else
1256                                     func (stream, "]");
1257                                 }
1258                               else
1259                                 {
1260                                   func (stream, "], %s",
1261                                         (((given & 0x00800000) == 0)
1262                                          ? "-" : ""));
1263                                   arm_decode_shift (given, func, stream);
1264                                 }
1265                             }
1266                         }
1267                       break;
1268
1269                     case 's':
1270                       if ((given & 0x004f0000) == 0x004f0000)
1271                         {
1272                           /* PC relative with immediate offset.  */
1273                           int offset = ((given & 0xf00) >> 4) | (given & 0xf);
1274
1275                           if ((given & 0x00800000) == 0)
1276                             offset = -offset;
1277
1278                           func (stream, "[pc, #%d]\t; ", offset);
1279                           info->print_address_func (offset + pc + 8, info);
1280                         }
1281                       else
1282                         {
1283                           func (stream, "[%s",
1284                                 arm_regnames[(given >> 16) & 0xf]);
1285                           if ((given & 0x01000000) != 0)
1286                             {
1287                               /* Pre-indexed.  */
1288                               if ((given & 0x00400000) == 0x00400000)
1289                                 {
1290                                   /* Immediate.  */
1291                                   int offset = ((given & 0xf00) >> 4) | (given & 0xf);
1292                                   if (offset)
1293                                     func (stream, ", #%s%d",
1294                                           (((given & 0x00800000) == 0)
1295                                            ? "-" : ""), offset);
1296                                 }
1297                               else
1298                                 {
1299                                   /* Register.  */
1300                                   func (stream, ", %s%s",
1301                                         (((given & 0x00800000) == 0)
1302                                          ? "-" : ""),
1303                                         arm_regnames[given & 0xf]);
1304                                 }
1305
1306                               func (stream, "]%s",
1307                                     ((given & 0x00200000) != 0) ? "!" : "");
1308                             }
1309                           else
1310                             {
1311                               /* Post-indexed.  */
1312                               if ((given & 0x00400000) == 0x00400000)
1313                                 {
1314                                   /* Immediate.  */
1315                                   int offset = ((given & 0xf00) >> 4) | (given & 0xf);
1316                                   if (offset)
1317                                     func (stream, "], #%s%d",
1318                                           (((given & 0x00800000) == 0)
1319                                            ? "-" : ""), offset);
1320                                   else
1321                                     func (stream, "]");
1322                                 }
1323                               else
1324                                 {
1325                                   /* Register.  */
1326                                   func (stream, "], %s%s",
1327                                         (((given & 0x00800000) == 0)
1328                                          ? "-" : ""),
1329                                         arm_regnames[given & 0xf]);
1330                                 }
1331                             }
1332                         }
1333                       break;
1334
1335                     case 'b':
1336                       {
1337                         int disp = (((given & 0xffffff) ^ 0x800000) - 0x800000);
1338                         info->print_address_func (disp*4 + pc + 8, info);
1339                       }
1340                       break;
1341
1342                     case 'c':
1343                       func (stream, "%s",
1344                             arm_conditional [(given >> 28) & 0xf]);
1345                       break;
1346
1347                     case 'm':
1348                       {
1349                         int started = 0;
1350                         int reg;
1351
1352                         func (stream, "{");
1353                         for (reg = 0; reg < 16; reg++)
1354                           if ((given & (1 << reg)) != 0)
1355                             {
1356                               if (started)
1357                                 func (stream, ", ");
1358                               started = 1;
1359                               func (stream, "%s", arm_regnames[reg]);
1360                             }
1361                         func (stream, "}");
1362                       }
1363                       break;
1364
1365                     case 'o':
1366                       if ((given & 0x02000000) != 0)
1367                         {
1368                           int rotate = (given & 0xf00) >> 7;
1369                           int immed = (given & 0xff);
1370                           immed = (((immed << (32 - rotate))
1371                                     | (immed >> rotate)) & 0xffffffff);
1372                           func (stream, "#%d\t; 0x%x", immed, immed);
1373                         }
1374                       else
1375                         arm_decode_shift (given, func, stream);
1376                       break;
1377
1378                     case 'p':
1379                       if ((given & 0x0000f000) == 0x0000f000)
1380                         func (stream, "p");
1381                       break;
1382
1383                     case 't':
1384                       if ((given & 0x01200000) == 0x00200000)
1385                         func (stream, "t");
1386                       break;
1387
1388                     case 'A':
1389                       func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
1390
1391                       if ((given & (1 << 24)) != 0)
1392                         {
1393                           int offset = given & 0xff;
1394
1395                           if (offset)
1396                             func (stream, ", #%s%d]%s",
1397                                   ((given & 0x00800000) == 0 ? "-" : ""),
1398                                   offset * 4,
1399                                   ((given & 0x00200000) != 0 ? "!" : ""));
1400                           else
1401                             func (stream, "]");
1402                         }
1403                       else
1404                         {
1405                           int offset = given & 0xff;
1406
1407                           func (stream, "]");
1408
1409                           if (given & (1 << 21))
1410                             {
1411                               if (offset)
1412                                 func (stream, ", #%s%d",
1413                                       ((given & 0x00800000) == 0 ? "-" : ""),
1414                                       offset * 4);
1415                             }
1416                           else
1417                             func (stream, ", {%d}", offset);
1418                         }
1419                       break;
1420
1421                     case 'B':
1422                       /* Print ARM V5 BLX(1) address: pc+25 bits.  */
1423                       {
1424                         bfd_vma address;
1425                         bfd_vma offset = 0;
1426
1427                         if (given & 0x00800000)
1428                           /* Is signed, hi bits should be ones.  */
1429                           offset = (-1) ^ 0x00ffffff;
1430
1431                         /* Offset is (SignExtend(offset field)<<2).  */
1432                         offset += given & 0x00ffffff;
1433                         offset <<= 2;
1434                         address = offset + pc + 8;
1435
1436                         if (given & 0x01000000)
1437                           /* H bit allows addressing to 2-byte boundaries.  */
1438                           address += 2;
1439
1440                         info->print_address_func (address, info);
1441                       }
1442                       break;
1443
1444                     case 'I':
1445                       /* Print a Cirrus/DSP shift immediate.  */
1446                       /* Immediates are 7bit signed ints with bits 0..3 in
1447                          bits 0..3 of opcode and bits 4..6 in bits 5..7
1448                          of opcode.  */
1449                       {
1450                         int imm;
1451
1452                         imm = (given & 0xf) | ((given & 0xe0) >> 1);
1453
1454                         /* Is ``imm'' a negative number?  */
1455                         if (imm & 0x40)
1456                           imm |= (-1 << 7);
1457
1458                         func (stream, "%d", imm);
1459                       }
1460
1461                       break;
1462
1463                     case 'C':
1464                       func (stream, "_");
1465                       if (given & 0x80000)
1466                         func (stream, "f");
1467                       if (given & 0x40000)
1468                         func (stream, "s");
1469                       if (given & 0x20000)
1470                         func (stream, "x");
1471                       if (given & 0x10000)
1472                         func (stream, "c");
1473                       break;
1474
1475                     case 'F':
1476                       switch (given & 0x00408000)
1477                         {
1478                         case 0:
1479                           func (stream, "4");
1480                           break;
1481                         case 0x8000:
1482                           func (stream, "1");
1483                           break;
1484                         case 0x00400000:
1485                           func (stream, "2");
1486                           break;
1487                         default:
1488                           func (stream, "3");
1489                         }
1490                       break;
1491
1492                     case 'P':
1493                       switch (given & 0x00080080)
1494                         {
1495                         case 0:
1496                           func (stream, "s");
1497                           break;
1498                         case 0x80:
1499                           func (stream, "d");
1500                           break;
1501                         case 0x00080000:
1502                           func (stream, "e");
1503                           break;
1504                         default:
1505                           func (stream, _("<illegal precision>"));
1506                           break;
1507                         }
1508                       break;
1509                     case 'Q':
1510                       switch (given & 0x00408000)
1511                         {
1512                         case 0:
1513                           func (stream, "s");
1514                           break;
1515                         case 0x8000:
1516                           func (stream, "d");
1517                           break;
1518                         case 0x00400000:
1519                           func (stream, "e");
1520                           break;
1521                         default:
1522                           func (stream, "p");
1523                           break;
1524                         }
1525                       break;
1526                     case 'R':
1527                       switch (given & 0x60)
1528                         {
1529                         case 0:
1530                           break;
1531                         case 0x20:
1532                           func (stream, "p");
1533                           break;
1534                         case 0x40:
1535                           func (stream, "m");
1536                           break;
1537                         default:
1538                           func (stream, "z");
1539                           break;
1540                         }
1541                       break;
1542
1543                     case '0': case '1': case '2': case '3': case '4':
1544                     case '5': case '6': case '7': case '8': case '9':
1545                       {
1546                         int bitstart = *c++ - '0';
1547                         int bitend = 0;
1548                         while (*c >= '0' && *c <= '9')
1549                           bitstart = (bitstart * 10) + *c++ - '0';
1550
1551                         switch (*c)
1552                           {
1553                           case '-':
1554                             c++;
1555
1556                             while (*c >= '0' && *c <= '9')
1557                               bitend = (bitend * 10) + *c++ - '0';
1558
1559                             if (!bitend)
1560                               abort ();
1561
1562                             switch (*c)
1563                               {
1564                               case 'r':
1565                                 {
1566                                   long reg;
1567
1568                                   reg = given >> bitstart;
1569                                   reg &= (2 << (bitend - bitstart)) - 1;
1570
1571                                   func (stream, "%s", arm_regnames[reg]);
1572                                 }
1573                                 break;
1574                               case 'd':
1575                                 {
1576                                   long reg;
1577
1578                                   reg = given >> bitstart;
1579                                   reg &= (2 << (bitend - bitstart)) - 1;
1580
1581                                   func (stream, "%ld", reg);
1582                                 }
1583                                 break;
1584                               case 'W':
1585                                 {
1586                                   long reg;
1587
1588                                   reg = given >> bitstart;
1589                                   reg &= (2 << (bitend - bitstart)) - 1;
1590
1591                                   func (stream, "%ld", reg + 1);
1592                                 }
1593                                 break;
1594                               case 'x':
1595                                 {
1596                                   long reg;
1597
1598                                   reg = given >> bitstart;
1599                                   reg &= (2 << (bitend - bitstart)) - 1;
1600
1601                                   func (stream, "0x%08lx", reg);
1602
1603                                   /* Some SWI instructions have special
1604                                      meanings.  */
1605                                   if ((given & 0x0fffffff) == 0x0FF00000)
1606                                     func (stream, "\t; IMB");
1607                                   else if ((given & 0x0fffffff) == 0x0FF00001)
1608                                     func (stream, "\t; IMBRange");
1609                                 }
1610                                 break;
1611                               case 'X':
1612                                 {
1613                                   long reg;
1614
1615                                   reg = given >> bitstart;
1616                                   reg &= (2 << (bitend - bitstart)) - 1;
1617
1618                                   func (stream, "%01lx", reg & 0xf);
1619                                 }
1620                                 break;
1621                               case 'f':
1622                                 {
1623                                   long reg;
1624
1625                                   reg = given >> bitstart;
1626                                   reg &= (2 << (bitend - bitstart)) - 1;
1627
1628                                   if (reg > 7)
1629                                     func (stream, "#%s",
1630                                           arm_fp_const[reg & 7]);
1631                                   else
1632                                     func (stream, "f%ld", reg);
1633                                 }
1634                                 break;
1635
1636                               case 'w':
1637                                 {
1638                                   long reg;
1639
1640                                   if (bitstart != bitend)
1641                                     {
1642                                       reg = given >> bitstart;
1643                                       reg &= (2 << (bitend - bitstart)) - 1;
1644                                       if (bitend - bitstart == 1)
1645                                         func (stream, "%s", iwmmxt_wwnames[reg]);
1646                                       else
1647                                         func (stream, "%s", iwmmxt_wwssnames[reg]);
1648                                     }
1649                                   else
1650                                     {
1651                                       reg = (((given >> 8)  & 0x1) |
1652                                              ((given >> 22) & 0x1));
1653                                       func (stream, "%s", iwmmxt_wwnames[reg]);
1654                                     }
1655                                 }
1656                                 break;
1657
1658                               case 'g':
1659                                 {
1660                                   long reg;
1661                                   reg = given >> bitstart;
1662                                   reg &= (2 << (bitend - bitstart)) - 1;
1663                                   func (stream, "%s", iwmmxt_regnames[reg]);
1664                                 }
1665                                 break;
1666
1667                               case 'G':
1668                                 {
1669                                   long reg;
1670                                   reg = given >> bitstart;
1671                                   reg &= (2 << (bitend - bitstart)) - 1;
1672                                   func (stream, "%s", iwmmxt_cregnames[reg]);
1673                                 }
1674                                 break;
1675
1676                               default:
1677                                 abort ();
1678                               }
1679                             break;
1680
1681                           case 'y':
1682                           case 'z':
1683                             {
1684                               int single = *c == 'y';
1685                               int regno;
1686
1687                               switch (bitstart)
1688                                 {
1689                                 case 4: /* Sm pair */
1690                                   func (stream, "{");
1691                                   /* Fall through.  */
1692                                 case 0: /* Sm, Dm */
1693                                   regno = given & 0x0000000f;
1694                                   if (single)
1695                                     {
1696                                       regno <<= 1;
1697                                       regno += (given >> 5) & 1;
1698                                     }
1699                                   break;
1700
1701                                 case 1: /* Sd, Dd */
1702                                   regno = (given >> 12) & 0x0000000f;
1703                                   if (single)
1704                                     {
1705                                       regno <<= 1;
1706                                       regno += (given >> 22) & 1;
1707                                     }
1708                                   break;
1709
1710                                 case 2: /* Sn, Dn */
1711                                   regno = (given >> 16) & 0x0000000f;
1712                                   if (single)
1713                                     {
1714                                       regno <<= 1;
1715                                       regno += (given >> 7) & 1;
1716                                     }
1717                                   break;
1718
1719                                 case 3: /* List */
1720                                   func (stream, "{");
1721                                   regno = (given >> 12) & 0x0000000f;
1722                                   if (single)
1723                                     {
1724                                       regno <<= 1;
1725                                       regno += (given >> 22) & 1;
1726                                     }
1727                                   break;
1728
1729
1730                                 default:
1731                                   abort ();
1732                                 }
1733
1734                               func (stream, "%c%d", single ? 's' : 'd', regno);
1735
1736                               if (bitstart == 3)
1737                                 {
1738                                   int count = given & 0xff;
1739
1740                                   if (single == 0)
1741                                     count >>= 1;
1742
1743                                   if (--count)
1744                                     {
1745                                       func (stream, "-%c%d",
1746                                             single ? 's' : 'd',
1747                                             regno + count);
1748                                     }
1749
1750                                   func (stream, "}");
1751                                 }
1752                               else if (bitstart == 4)
1753                                 func (stream, ", %c%d}", single ? 's' : 'd',
1754                                       regno + 1);
1755
1756                               break;
1757                             }
1758
1759                           case '`':
1760                             c++;
1761                             if ((given & (1 << bitstart)) == 0)
1762                               func (stream, "%c", *c);
1763                             break;
1764                           case '\'':
1765                             c++;
1766                             if ((given & (1 << bitstart)) != 0)
1767                               func (stream, "%c", *c);
1768                             break;
1769                           case '?':
1770                             ++c;
1771                             if ((given & (1 << bitstart)) != 0)
1772                               func (stream, "%c", *c++);
1773                             else
1774                               func (stream, "%c", *++c);
1775                             break;
1776                           default:
1777                             abort ();
1778                           }
1779                         break;
1780
1781                       case 'L':
1782                         switch (given & 0x00400100)
1783                           {
1784                           case 0x00000000: func (stream, "b"); break;
1785                           case 0x00400000: func (stream, "h"); break;
1786                           case 0x00000100: func (stream, "w"); break;
1787                           case 0x00400100: func (stream, "d"); break;
1788                           default:
1789                             break;
1790                           }
1791                         break;
1792
1793                       case 'Z':
1794                         {
1795                           int value;
1796                           /* given (20, 23) | given (0, 3) */
1797                           value = ((given >> 16) & 0xf0) | (given & 0xf);
1798                           func (stream, "%d", value);
1799                         }
1800                         break;
1801
1802                       case 'l':
1803                         /* This is like the 'A' operator, except that if
1804                            the width field "M" is zero, then the offset is
1805                            *not* multiplied by four.  */
1806                         {
1807                           int offset = given & 0xff;
1808                           int multiplier = (given & 0x00000100) ? 4 : 1;
1809
1810                           func (stream, "[%s", arm_regnames [(given >> 16) & 0xf]);
1811
1812                           if (offset)
1813                             {
1814                               if ((given & 0x01000000) != 0)
1815                                 func (stream, ", #%s%d]%s",
1816                                       ((given & 0x00800000) == 0 ? "-" : ""),
1817                                       offset * multiplier,
1818                                       ((given & 0x00200000) != 0 ? "!" : ""));
1819                               else
1820                                 func (stream, "], #%s%d",
1821                                       ((given & 0x00800000) == 0 ? "-" : ""),
1822                                       offset * multiplier);
1823                             }
1824                           else
1825                             func (stream, "]");
1826                         }
1827                         break;
1828
1829                       case 'e':
1830                         {
1831                           int imm;
1832
1833                           imm = (given & 0xf) | ((given & 0xfff00) >> 4);
1834                           func (stream, "%d", imm);
1835                         }
1836                         break;
1837
1838                       case 'E':
1839                         /* LSB and WIDTH fields of BFI or BFC.  The machine-
1840                            language instruction encodes LSB and MSB.  */
1841                         {
1842                           long msb = (given & 0x001f0000) >> 16;
1843                           long lsb = (given & 0x00000f80) >> 7;
1844
1845                           long width = msb - lsb + 1;
1846                           if (width > 0)
1847                             func (stream, "#%lu, #%lu", lsb, width);
1848                           else
1849                             func (stream, "(invalid: %lu:%lu)", lsb, msb);
1850                         }
1851                         break;
1852
1853                       case 'V':
1854                         /* 16-bit unsigned immediate from a MOVT or MOVW
1855                            instruction, encoded in bits 0:11 and 15:19.  */
1856                         {
1857                           long hi = (given & 0x000f0000) >> 4;
1858                           long lo = (given & 0x00000fff);
1859                           long imm16 = hi | lo;
1860                           func (stream, "#%lu\t; 0x%lx", imm16, imm16);
1861                         }
1862                         break;
1863
1864                       default:
1865                         abort ();
1866                       }
1867                     }
1868                 }
1869               else
1870                 func (stream, "%c", *c);
1871             }
1872           return;
1873         }
1874     }
1875   abort ();
1876 }
1877
1878 /* Print one 16-bit Thumb instruction from PC on INFO->STREAM.  */
1879
1880 static void
1881 print_insn_thumb16 (bfd_vma pc, struct disassemble_info *info, long given)
1882 {
1883   const struct opcode16 *insn;
1884   void *stream = info->stream;
1885   fprintf_ftype func = info->fprintf_func;
1886
1887   for (insn = thumb_opcodes; insn->assembler; insn++)
1888     if ((given & insn->mask) == insn->value)
1889       {
1890         const char *c = insn->assembler;
1891         for (; *c; c++)
1892           {
1893             int domaskpc = 0;
1894             int domasklr = 0;
1895
1896             if (*c != '%')
1897               {
1898                 func (stream, "%c", *c);
1899                 continue;
1900               }
1901
1902             switch (*++c)
1903               {
1904               case '%':
1905                 func (stream, "%%");
1906                 break;
1907
1908               case 'S':
1909                 {
1910                   long reg;
1911
1912                   reg = (given >> 3) & 0x7;
1913                   if (given & (1 << 6))
1914                     reg += 8;
1915
1916                   func (stream, "%s", arm_regnames[reg]);
1917                 }
1918                 break;
1919
1920               case 'D':
1921                 {
1922                   long reg;
1923
1924                   reg = given & 0x7;
1925                   if (given & (1 << 7))
1926                     reg += 8;
1927
1928                   func (stream, "%s", arm_regnames[reg]);
1929                 }
1930                 break;
1931
1932               case 'N':
1933                 if (given & (1 << 8))
1934                   domasklr = 1;
1935                 /* Fall through.  */
1936               case 'O':
1937                 if (*c == 'O' && (given & (1 << 8)))
1938                   domaskpc = 1;
1939                 /* Fall through.  */
1940               case 'M':
1941                 {
1942                   int started = 0;
1943                   int reg;
1944
1945                   func (stream, "{");
1946
1947                   /* It would be nice if we could spot
1948                      ranges, and generate the rS-rE format: */
1949                   for (reg = 0; (reg < 8); reg++)
1950                     if ((given & (1 << reg)) != 0)
1951                       {
1952                         if (started)
1953                           func (stream, ", ");
1954                         started = 1;
1955                         func (stream, "%s", arm_regnames[reg]);
1956                       }
1957
1958                   if (domasklr)
1959                     {
1960                       if (started)
1961                         func (stream, ", ");
1962                       started = 1;
1963                       func (stream, arm_regnames[14] /* "lr" */);
1964                     }
1965
1966                   if (domaskpc)
1967                     {
1968                       if (started)
1969                         func (stream, ", ");
1970                       func (stream, arm_regnames[15] /* "pc" */);
1971                     }
1972
1973                   func (stream, "}");
1974                 }
1975                 break;
1976
1977               case 'b':
1978                 /* Print ARM V6T2 CZB address: pc+4+6 bits.  */
1979                 {
1980                   bfd_vma address = (pc + 4
1981                                      + ((given & 0x00f8) >> 2)
1982                                      + ((given & 0x0200) >> 3));
1983                   info->print_address_func (address, info);
1984                 }
1985                 break;
1986
1987               case 's':
1988                 /* Right shift immediate -- bits 6..10; 1-31 print
1989                    as themselves, 0 prints as 32.  */
1990                 {
1991                   long imm = (given & 0x07c0) >> 6;
1992                   if (imm == 0)
1993                     imm = 32;
1994                   func (stream, "#%ld", imm);
1995                 }
1996                 break;
1997
1998               case '0': case '1': case '2': case '3': case '4':
1999               case '5': case '6': case '7': case '8': case '9':
2000                 {
2001                   int bitstart = *c++ - '0';
2002                   int bitend = 0;
2003
2004                   while (*c >= '0' && *c <= '9')
2005                     bitstart = (bitstart * 10) + *c++ - '0';
2006
2007                   switch (*c)
2008                     {
2009                     case '-':
2010                       {
2011                         long reg;
2012
2013                         c++;
2014                         while (*c >= '0' && *c <= '9')
2015                           bitend = (bitend * 10) + *c++ - '0';
2016                         if (!bitend)
2017                           abort ();
2018                         reg = given >> bitstart;
2019                         reg &= (2 << (bitend - bitstart)) - 1;
2020                         switch (*c)
2021                           {
2022                           case 'r':
2023                             func (stream, "%s", arm_regnames[reg]);
2024                             break;
2025
2026                           case 'd':
2027                             func (stream, "%ld", reg);
2028                             break;
2029
2030                           case 'H':
2031                             func (stream, "%ld", reg << 1);
2032                             break;
2033
2034                           case 'W':
2035                             func (stream, "%ld", reg << 2);
2036                             break;
2037
2038                           case 'a':
2039                             /* PC-relative address -- the bottom two
2040                                bits of the address are dropped
2041                                before the calculation.  */
2042                             info->print_address_func
2043                               (((pc + 4) & ~3) + (reg << 2), info);
2044                             break;
2045
2046                           case 'x':
2047                             func (stream, "0x%04lx", reg);
2048                             break;
2049
2050                           case 'B':
2051                             reg = ((reg ^ (1 << bitend)) - (1 << bitend));
2052                             info->print_address_func (reg * 2 + pc + 4, info);
2053                             break;
2054
2055                           case 'c':
2056                             {
2057                               /* Must print 0xE as 'al' to distinguish
2058                                  unconditional B from conditional BAL.  */
2059                               if (reg == 0xE)
2060                                 func (stream, "al");
2061                               else
2062                                 func (stream, "%s", arm_conditional [reg]);
2063                             }
2064                             break;
2065
2066                           default:
2067                             abort ();
2068                           }
2069                       }
2070                       break;
2071
2072                     case '\'':
2073                       c++;
2074                       if ((given & (1 << bitstart)) != 0)
2075                         func (stream, "%c", *c);
2076                       break;
2077
2078                     case '?':
2079                       ++c;
2080                       if ((given & (1 << bitstart)) != 0)
2081                         func (stream, "%c", *c++);
2082                       else
2083                         func (stream, "%c", *++c);
2084                       break;
2085
2086                     default:
2087                       abort ();
2088                     }
2089                 }
2090                 break;
2091
2092               default:
2093                 abort ();
2094               }
2095           }
2096         return;
2097       }
2098
2099   /* No match.  */
2100   abort ();
2101 }
2102
2103 /* Print one 32-bit Thumb instruction from PC on INFO->STREAM.  */
2104
2105 static void
2106 print_insn_thumb32 (bfd_vma pc, struct disassemble_info *info, long given)
2107 {
2108   const struct opcode32 *insn;
2109   void *stream = info->stream;
2110   fprintf_ftype func = info->fprintf_func;
2111
2112   for (insn = thumb32_opcodes; insn->assembler; insn++)
2113     if ((given & insn->mask) == insn->value)
2114       {
2115         const char *c = insn->assembler;
2116         for (; *c; c++)
2117           {
2118             if (*c != '%')
2119               {
2120                 func (stream, "%c", *c);
2121                 continue;
2122               }
2123
2124             switch (*++c)
2125               {
2126               case '%':
2127                 func (stream, "%%");
2128                 break;
2129
2130               case 'I':
2131                 {
2132                   unsigned int imm12 = 0;
2133                   imm12 |= (given & 0x000000ffu);
2134                   imm12 |= (given & 0x00007000u) >> 4;
2135                   imm12 |= (given & 0x04000000u) >> 15;
2136                   func (stream, "#%u\t; 0x%x", imm12, imm12);
2137                 }
2138                 break;
2139
2140               case 'M':
2141                 {
2142                   unsigned int bits = 0, imm, imm8, mod;
2143                   bits |= (given & 0x000000ffu);
2144                   bits |= (given & 0x00007000u) >> 4;
2145                   bits |= (given & 0x04000000u) >> 15;
2146                   imm8 = (bits & 0x0ff);
2147                   mod = (bits & 0xf00) >> 8;
2148                   switch (mod)
2149                     {
2150                     case 0: imm = imm8; break;
2151                     case 1: imm = ((imm8<<16) | imm8); break;
2152                     case 2: imm = ((imm8<<24) | (imm8 << 8)); break;
2153                     case 3: imm = ((imm8<<24) | (imm8 << 16) | (imm8 << 8) | imm8); break;
2154                     default:
2155                       mod  = (bits & 0xf80) >> 7;
2156                       imm8 = (bits & 0x07f) | 0x80;
2157                       imm  = (((imm8 << (32 - mod)) | (imm8 >> mod)) & 0xffffffff);
2158                     }
2159                   func (stream, "#%u\t; 0x%x", imm, imm);
2160                 }
2161                 break;
2162
2163               case 'J':
2164                 {
2165                   unsigned int imm = 0;
2166                   imm |= (given & 0x000000ffu);
2167                   imm |= (given & 0x00007000u) >> 4;
2168                   imm |= (given & 0x04000000u) >> 15;
2169                   imm |= (given & 0x000f0000u) >> 4;
2170                   func (stream, "#%u\t; 0x%x", imm, imm);
2171                 }
2172                 break;
2173
2174               case 'K':
2175                 {
2176                   unsigned int imm = 0;
2177                   imm |= (given & 0x000f0000u) >> 16;
2178                   imm |= (given & 0x00000ff0u) >> 0;
2179                   imm |= (given & 0x0000000fu) << 12;
2180                   func (stream, "#%u\t; 0x%x", imm, imm);
2181                 }
2182                 break;
2183
2184               case 'S':
2185                 {
2186                   unsigned int reg = (given & 0x0000000fu);
2187                   unsigned int stp = (given & 0x00000030u) >> 4;
2188                   unsigned int imm = 0;
2189                   imm |= (given & 0x000000c0u) >> 6;
2190                   imm |= (given & 0x00007000u) >> 10;
2191
2192                   func (stream, "%s", arm_regnames[reg]);
2193                   switch (stp)
2194                     {
2195                     case 0:
2196                       if (imm > 0)
2197                         func (stream, ", lsl #%u", imm);
2198                       break;
2199
2200                     case 1:
2201                       if (imm == 0)
2202                         imm = 32;
2203                       func (stream, ", lsr #%u", imm);
2204                       break;
2205
2206                     case 2:
2207                       if (imm == 0)
2208                         imm = 32;
2209                       func (stream, ", asr #%u", imm);
2210                       break;
2211
2212                     case 3:
2213                       if (imm == 0)
2214                         func (stream, ", rrx");
2215                       else
2216                         func (stream, ", ror #%u", imm);
2217                     }
2218                 }
2219                 break;
2220
2221               case 'a':
2222                 {
2223                   unsigned int Rn  = (given & 0x000f0000) >> 16;
2224                   unsigned int U   = (given & 0x00800000) >> 23;
2225                   unsigned int op  = (given & 0x00000f00) >> 8;
2226                   unsigned int i12 = (given & 0x00000fff);
2227                   unsigned int i8  = (given & 0x000000ff);
2228                   bfd_boolean writeback = FALSE, postind = FALSE;
2229                   int offset = 0;
2230
2231                   func (stream, "[%s", arm_regnames[Rn]);
2232                   if (U) /* 12-bit positive immediate offset */
2233                     offset = i12;
2234                   else if (Rn == 15) /* 12-bit negative immediate offset */
2235                     offset = -(int)i12;
2236                   else if (op == 0x0) /* shifted register offset */
2237                     {
2238                       unsigned int Rm = (i8 & 0x0f);
2239                       unsigned int sh = (i8 & 0x30) >> 4;
2240                       func (stream, ", %s", arm_regnames[Rm]);
2241                       if (sh)
2242                         func (stream, ", lsl #%u", sh);
2243                       func (stream, "]");
2244                       break;
2245                     }
2246                   else switch (op)
2247                     {
2248                     case 0xE:  /* 8-bit positive immediate offset */
2249                       offset = i8;
2250                       break;
2251
2252                     case 0xC:  /* 8-bit negative immediate offset */
2253                       offset = -i8;
2254                       break;
2255
2256                     case 0xF:  /* 8-bit + preindex with wb */
2257                       offset = i8;
2258                       writeback = TRUE;
2259                       break;
2260
2261                     case 0xD:  /* 8-bit - preindex with wb */
2262                       offset = -i8;
2263                       writeback = TRUE;
2264                       break;
2265
2266                     case 0xB:  /* 8-bit + postindex */
2267                       offset = i8;
2268                       postind = TRUE;
2269                       break;
2270
2271                     case 0x9:  /* 8-bit - postindex */
2272                       offset = -i8;
2273                       postind = TRUE;
2274                       break;
2275
2276                     default:
2277                       func (stream, ", <undefined>]");
2278                       goto skip;
2279                     }
2280
2281                   if (postind)
2282                     func (stream, "], #%d", offset);
2283                   else
2284                     {
2285                       if (offset)
2286                         func (stream, ", #%d", offset);
2287                       func (stream, writeback ? "]!" : "]");
2288                     }
2289
2290                   if (Rn == 15)
2291                     {
2292                       func (stream, "\t; ");
2293                       info->print_address_func (((pc + 4) & ~3) + offset, info);
2294                     }
2295                 }
2296               skip:
2297                 break;
2298
2299               case 'A':
2300                 {
2301                   unsigned int P   = (given & 0x01000000) >> 24;
2302                   unsigned int U   = (given & 0x00800000) >> 23;
2303                   unsigned int W   = (given & 0x00400000) >> 21;
2304                   unsigned int Rn  = (given & 0x000f0000) >> 16;
2305                   unsigned int off = (given & 0x000000ff);
2306
2307                   func (stream, "[%s", arm_regnames[Rn]);
2308                   if (P)
2309                     {
2310                       if (off || !U)
2311                         func (stream, ", #%c%u", U ? '+' : '-', off * 4);
2312                       func (stream, "]");
2313                       if (W)
2314                         func (stream, "!");
2315                     }
2316                   else
2317                     {
2318                       func (stream, "], ");
2319                       if (W)
2320                         func (stream, "#%c%u", U ? '+' : '-', off * 4);
2321                       else
2322                         func (stream, "{%u}", off);
2323                     }
2324                 }
2325                 break;
2326
2327               case 'w':
2328                 {
2329                   unsigned int Sbit = (given & 0x01000000) >> 24;
2330                   unsigned int type = (given & 0x00600000) >> 21;
2331                   switch (type)
2332                     {
2333                     case 0: func (stream, Sbit ? "sb" : "b"); break;
2334                     case 1: func (stream, Sbit ? "sh" : "h"); break;
2335                     case 2:
2336                       if (Sbit)
2337                         func (stream, "??");
2338                       break;
2339                     case 3:
2340                       func (stream, "??");
2341                       break;
2342                     }
2343                 }
2344                 break;
2345
2346               case 'm':
2347                 {
2348                   int started = 0;
2349                   int reg;
2350
2351                   func (stream, "{");
2352                   for (reg = 0; reg < 16; reg++)
2353                     if ((given & (1 << reg)) != 0)
2354                       {
2355                         if (started)
2356                           func (stream, ", ");
2357                         started = 1;
2358                         func (stream, "%s", arm_regnames[reg]);
2359                       }
2360                   func (stream, "}");
2361                 }
2362                 break;
2363
2364               case 'E':
2365                 {
2366                   unsigned int msb = (given & 0x0000001f);
2367                   unsigned int lsb = 0;
2368                   lsb |= (given & 0x000000c0u) >> 6;
2369                   lsb |= (given & 0x00007000u) >> 10;
2370                   func (stream, "#%u, #%u", lsb, msb - lsb + 1);
2371                 }
2372                 break;
2373
2374               case 'F':
2375                 {
2376                   unsigned int width = (given & 0x0000001f) + 1;
2377                   unsigned int lsb = 0;
2378                   lsb |= (given & 0x000000c0u) >> 6;
2379                   lsb |= (given & 0x00007000u) >> 10;
2380                   func (stream, "#%u, #%u", lsb, width);
2381                 }
2382                 break;
2383
2384               case 'b':
2385                 {
2386                   unsigned int S = (given & 0x04000000u) >> 26;
2387                   unsigned int J1 = (given & 0x00002000u) >> 13;
2388                   unsigned int J2 = (given & 0x00000800u) >> 11;
2389                   int offset = 0;
2390
2391                   offset |= !S << 20;
2392                   offset |= J2 << 19;
2393                   offset |= J1 << 18;
2394                   offset |= (given & 0x003f0000) >> 4;
2395                   offset |= (given & 0x000007ff) << 1;
2396                   offset -= (1 << 20);
2397
2398                   info->print_address_func (pc + 4 + offset, info);
2399                 }
2400                 break;
2401
2402               case 'B':
2403                 {
2404                   unsigned int S = (given & 0x04000000u) >> 26;
2405                   unsigned int I1 = (given & 0x00002000u) >> 13;
2406                   unsigned int I2 = (given & 0x00000800u) >> 11;
2407                   int offset = 0;
2408
2409                   offset |= !S << 24;
2410                   offset |= !(I1 ^ S) << 23;
2411                   offset |= !(I2 ^ S) << 22;
2412                   offset |= (given & 0x03ff0000u) >> 4;
2413                   offset |= (given & 0x000007ffu) << 1;
2414                   offset -= (1 << 24);
2415
2416                   info->print_address_func (pc + 4 + offset, info);
2417                 }
2418                 break;
2419
2420               case 's':
2421                 {
2422                   unsigned int shift = 0;
2423                   shift |= (given & 0x000000c0u) >> 6;
2424                   shift |= (given & 0x00007000u) >> 10;
2425                   if (given & 0x00200000u)
2426                     func (stream, ", asr #%u", shift);
2427                   else if (shift)
2428                     func (stream, ", lsl #%u", shift);
2429                   /* else print nothing - lsl #0 */
2430                 }
2431                 break;
2432
2433               case 'R':
2434                 {
2435                   unsigned int rot = (given & 0x00000030) >> 4;
2436                   if (rot)
2437                     func (stream, ", ror #%u", rot * 8);
2438                 }
2439                 break;
2440
2441               case '0': case '1': case '2': case '3': case '4':
2442               case '5': case '6': case '7': case '8': case '9':
2443                 {
2444                   int bitstart = *c++ - '0';
2445                   int bitend = 0;
2446                   unsigned int val;
2447                   while (*c >= '0' && *c <= '9')
2448                     bitstart = (bitstart * 10) + *c++ - '0';
2449
2450                   if (*c == '-')
2451                     {
2452                       c++;
2453                       while (*c >= '0' && *c <= '9')
2454                         bitend = (bitend * 10) + *c++ - '0';
2455                       if (!bitend)
2456                         abort ();
2457
2458                       val = given >> bitstart;
2459                       val &= (2 << (bitend - bitstart)) - 1;
2460                     }
2461                   else
2462                     val = (given >> bitstart) & 1;
2463
2464                   switch (*c)
2465                     {
2466                     case 'd': func (stream, "%u", val); break;
2467                     case 'W': func (stream, "%u", val * 4); break;
2468                     case 'r': func (stream, "%s", arm_regnames[val]); break;
2469
2470                     case 'c':
2471                       if (val == 0xE)
2472                         func (stream, "al");
2473                       else
2474                         func (stream, "%s", arm_conditional[val]);
2475                       break;
2476
2477                     case '\'':
2478                       if (val)
2479                         func (stream, "%c", c[1]);
2480                       c++;
2481                       break;
2482
2483                     case '`':
2484                       if (!val)
2485                         func (stream, "%c", c[1]);
2486                       c++;
2487                       break;
2488
2489                     case '?':
2490                       func (stream, "%c", val ? c[1] : c[2]);
2491                       c += 2;
2492                       break;
2493
2494                     default:
2495                       abort ();
2496                     }
2497                 }
2498                 break;
2499
2500               default:
2501                 abort ();
2502               }
2503           }
2504         return;
2505       }
2506
2507   /* No match.  */
2508   abort ();
2509 }
2510
2511 /* Disallow mapping symbols ($a, $b, $d, $t etc) from
2512    being displayed in symbol relative addresses.  */
2513
2514 bfd_boolean
2515 arm_symbol_is_valid (asymbol * sym,
2516                      struct disassemble_info * info ATTRIBUTE_UNUSED)
2517 {
2518   const char * name;
2519
2520   if (sym == NULL)
2521     return FALSE;
2522
2523   name = bfd_asymbol_name (sym);
2524
2525   return (name && *name != '$');
2526 }
2527
2528 /* Parse an individual disassembler option.  */
2529
2530 void
2531 parse_arm_disassembler_option (char *option)
2532 {
2533   if (option == NULL)
2534     return;
2535
2536   if (strneq (option, "reg-names-", 10))
2537     {
2538       int i;
2539
2540       option += 10;
2541
2542       for (i = NUM_ARM_REGNAMES; i--;)
2543         if (strneq (option, regnames[i].name, strlen (regnames[i].name)))
2544           {
2545             regname_selected = i;
2546             break;
2547           }
2548
2549       if (i < 0)
2550         /* XXX - should break 'option' at following delimiter.  */
2551         fprintf (stderr, _("Unrecognised register name set: %s\n"), option);
2552     }
2553   else if (strneq (option, "force-thumb", 11))
2554     force_thumb = 1;
2555   else if (strneq (option, "no-force-thumb", 14))
2556     force_thumb = 0;
2557   else
2558     /* XXX - should break 'option' at following delimiter.  */
2559     fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
2560
2561   return;
2562 }
2563
2564 /* Parse the string of disassembler options, spliting it at whitespaces
2565    or commas.  (Whitespace separators supported for backwards compatibility).  */
2566
2567 static void
2568 parse_disassembler_options (char *options)
2569 {
2570   if (options == NULL)
2571     return;
2572
2573   while (*options)
2574     {
2575       parse_arm_disassembler_option (options);
2576
2577       /* Skip forward to next seperator.  */
2578       while ((*options) && (! ISSPACE (*options)) && (*options != ','))
2579         ++ options;
2580       /* Skip forward past seperators.  */
2581       while (ISSPACE (*options) || (*options == ','))
2582         ++ options;
2583     }
2584 }
2585
2586 /* NOTE: There are no checks in these routines that
2587    the relevant number of data bytes exist.  */
2588
2589 static int
2590 print_insn (bfd_vma pc, struct disassemble_info *info, bfd_boolean little)
2591 {
2592   unsigned char b[4];
2593   long          given;
2594   int           status;
2595   int           is_thumb;
2596   int           size;
2597   void          (*printer) (bfd_vma, struct disassemble_info *, long);
2598
2599   if (info->disassembler_options)
2600     {
2601       parse_disassembler_options (info->disassembler_options);
2602
2603       /* To avoid repeated parsing of these options, we remove them here.  */
2604       info->disassembler_options = NULL;
2605     }
2606
2607   is_thumb = force_thumb;
2608
2609   if (!is_thumb && info->symbols != NULL)
2610     {
2611       if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)
2612         {
2613           coff_symbol_type * cs;
2614
2615           cs = coffsymbol (*info->symbols);
2616           is_thumb = (   cs->native->u.syment.n_sclass == C_THUMBEXT
2617                       || cs->native->u.syment.n_sclass == C_THUMBSTAT
2618                       || cs->native->u.syment.n_sclass == C_THUMBLABEL
2619                       || cs->native->u.syment.n_sclass == C_THUMBEXTFUNC
2620                       || cs->native->u.syment.n_sclass == C_THUMBSTATFUNC);
2621         }
2622       else if (bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour)
2623         {
2624           elf_symbol_type *  es;
2625           unsigned int       type;
2626
2627           es = *(elf_symbol_type **)(info->symbols);
2628           type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
2629
2630           is_thumb = (type == STT_ARM_TFUNC) || (type == STT_ARM_16BIT);
2631         }
2632     }
2633
2634   info->display_endian  = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;
2635   info->bytes_per_line = 4;
2636
2637   if (!is_thumb)
2638     {
2639       /* In ARM mode endianness is a straightforward issue: the instruction
2640          is four bytes long and is either ordered 0123 or 3210.  */
2641       printer = print_insn_arm;
2642       info->bytes_per_chunk = 4;
2643       size = 4;
2644
2645       status = info->read_memory_func (pc, (bfd_byte *)b, 4, info);
2646       if (little)
2647         given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
2648       else
2649         given = (b[3]) | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2650     }
2651   else
2652     {
2653       /* In Thumb mode we have the additional wrinkle of two
2654          instruction lengths.  Fortunately, the bits that determine
2655          the length of the current instruction are always to be found
2656          in the first two bytes.  */
2657       printer = print_insn_thumb16;
2658       info->bytes_per_chunk = 2;
2659       size = 2;
2660
2661       status = info->read_memory_func (pc, (bfd_byte *)b, 2, info);
2662       if (!status)
2663         {
2664           if (little)
2665             given = (b[0]) | (b[1] << 8);
2666           else
2667             given = (b[1]) | (b[0] << 8);
2668
2669           /* These bit patterns signal a four-byte Thumb
2670              instruction.  */
2671           if ((given & 0xF800) == 0xF800
2672               || (given & 0xF800) == 0xF000
2673               || (given & 0xF800) == 0xE800)
2674             {
2675               status = info->read_memory_func (pc + 2, (bfd_byte *)b, 2, info);
2676               if (little)
2677                 given = (b[0]) | (b[1] << 8) | (given << 16);
2678               else
2679                 given = (b[1]) | (b[0] << 8) | (given << 16);
2680
2681               printer = print_insn_thumb32;
2682               size = 4;
2683             }
2684         }
2685     }
2686
2687   if (status)
2688     {
2689       info->memory_error_func (status, pc, info);
2690       return -1;
2691     }
2692   if (info->flags & INSN_HAS_RELOC)
2693     /* If the instruction has a reloc associated with it, then
2694        the offset field in the instruction will actually be the
2695        addend for the reloc.  (We are using REL type relocs).
2696        In such cases, we can ignore the pc when computing
2697        addresses, since the addend is not currently pc-relative.  */
2698     pc = 0;
2699
2700   printer (pc, info, given);
2701   return size;
2702 }
2703
2704 int
2705 print_insn_big_arm (bfd_vma pc, struct disassemble_info *info)
2706 {
2707   return print_insn (pc, info, FALSE);
2708 }
2709
2710 int
2711 print_insn_little_arm (bfd_vma pc, struct disassemble_info *info)
2712 {
2713   return print_insn (pc, info, TRUE);
2714 }
2715
2716 void
2717 print_arm_disassembler_options (FILE *stream)
2718 {
2719   int i;
2720
2721   fprintf (stream, _("\n\
2722 The following ARM specific disassembler options are supported for use with\n\
2723 the -M switch:\n"));
2724
2725   for (i = NUM_ARM_REGNAMES; i--;)
2726     fprintf (stream, "  reg-names-%s %*c%s\n",
2727              regnames[i].name,
2728              (int)(14 - strlen (regnames[i].name)), ' ',
2729              regnames[i].description);
2730
2731   fprintf (stream, "  force-thumb              Assume all insns are Thumb insns\n");
2732   fprintf (stream, "  no-force-thumb           Examine preceeding label to determine an insn's type\n\n");
2733 }