gas/config/tc-arm.c

   1 /* tc-arm.c -- Assemble for the ARM
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4    Contributed by Richard Earnshaw ([email protected])
   5         Modified by David Taylor ([email protected])
   6         Cirrus coprocessor mods by Aldy Hernandez ([email protected])
   7
   8    This file is part of GAS, the GNU Assembler.
   9
  10    GAS is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    GAS is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with GAS; see the file COPYING.  If not, write to the Free
  22    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.  */
  24
  25 #include <string.h>
  26 #define  NO_RELOC 0
  27 #include "as.h"
  28 #include "safe-ctype.h"
  29
  30 /* Need TARGET_CPU.  */
  31 #include "config.h"
  32 #include "subsegs.h"
  33 #include "obstack.h"
  34 #include "symbols.h"
  35 #include "listing.h"
  36
  37 #ifdef OBJ_ELF
  38 #include "elf/arm.h"
  39 #include "dwarf2dbg.h"
  40 #endif
  41
  42 /* XXX Set this to 1 after the next binutils release */
  43 #define WARN_DEPRECATED 0
  44
  45 /* The following bitmasks control CPU extensions:  */
  46 #define ARM_EXT_V1       0x00000001     /* All processors (core set).  */
  47 #define ARM_EXT_V2       0x00000002     /* Multiply instructions.  */
  48 #define ARM_EXT_V2S      0x00000004     /* SWP instructions.       */
  49 #define ARM_EXT_V3       0x00000008     /* MSR MRS.                */
  50 #define ARM_EXT_V3M      0x00000010     /* Allow long multiplies.  */
  51 #define ARM_EXT_V4       0x00000020     /* Allow half word loads.  */
  52 #define ARM_EXT_V4T      0x00000040     /* Thumb v1.               */
  53 #define ARM_EXT_V5       0x00000080     /* Allow CLZ, etc.         */
  54 #define ARM_EXT_V5T      0x00000100     /* Thumb v2.               */
  55 #define ARM_EXT_V5ExP    0x00000200     /* DSP core set.           */
  56 #define ARM_EXT_V5E      0x00000400     /* DSP Double transfers.   */
  57 #define ARM_EXT_V5J      0x00000800     /* Jazelle extension.      */
  58
  59 /* Co-processor space extensions.  */
  60 #define ARM_CEXT_XSCALE   0x00800000    /* Allow MIA etc.          */
  61 #define ARM_CEXT_MAVERICK 0x00400000    /* Use Cirrus/DSP coprocessor.  */
  62 #define ARM_CEXT_IWMMXT   0x00200000    /* Intel Wireless MMX technology coprocessor.   */
  63
  64 /* Architectures are the sum of the base and extensions.  The ARM ARM (rev E)
  65    defines the following: ARMv3, ARMv3M, ARMv4xM, ARMv4, ARMv4TxM, ARMv4T,
  66    ARMv5xM, ARMv5, ARMv5TxM, ARMv5T, ARMv5TExP, ARMv5TE.  To these we add
  67    three more to cover cores prior to ARM6.  Finally, there are cores which
  68    implement further extensions in the co-processor space.  */
  69 #define ARM_ARCH_V1                       ARM_EXT_V1
  70 #define ARM_ARCH_V2     (ARM_ARCH_V1    | ARM_EXT_V2)
  71 #define ARM_ARCH_V2S    (ARM_ARCH_V2    | ARM_EXT_V2S)
  72 #define ARM_ARCH_V3     (ARM_ARCH_V2S   | ARM_EXT_V3)
  73 #define ARM_ARCH_V3M    (ARM_ARCH_V3    | ARM_EXT_V3M)
  74 #define ARM_ARCH_V4xM   (ARM_ARCH_V3    | ARM_EXT_V4)
  75 #define ARM_ARCH_V4     (ARM_ARCH_V3M   | ARM_EXT_V4)
  76 #define ARM_ARCH_V4TxM  (ARM_ARCH_V4xM  | ARM_EXT_V4T)
  77 #define ARM_ARCH_V4T    (ARM_ARCH_V4    | ARM_EXT_V4T)
  78 #define ARM_ARCH_V5xM   (ARM_ARCH_V4xM  | ARM_EXT_V5)
  79 #define ARM_ARCH_V5     (ARM_ARCH_V4    | ARM_EXT_V5)
  80 #define ARM_ARCH_V5TxM  (ARM_ARCH_V5xM  | ARM_EXT_V4T | ARM_EXT_V5T)
  81 #define ARM_ARCH_V5T    (ARM_ARCH_V5    | ARM_EXT_V4T | ARM_EXT_V5T)
  82 #define ARM_ARCH_V5TExP (ARM_ARCH_V5T   | ARM_EXT_V5ExP)
  83 #define ARM_ARCH_V5TE   (ARM_ARCH_V5TExP | ARM_EXT_V5E)
  84 #define ARM_ARCH_V5TEJ  (ARM_ARCH_V5TE  | ARM_EXT_V5J)
  85
  86 /* Processors with specific extensions in the co-processor space.  */
  87 #define ARM_ARCH_XSCALE (ARM_ARCH_V5TE  | ARM_CEXT_XSCALE)
  88 #define ARM_ARCH_IWMMXT (ARM_ARCH_XSCALE | ARM_CEXT_IWMMXT)
  89
  90 /* Some useful combinations:  */
  91 #define ARM_ANY         0x0000ffff      /* Any basic core.  */
  92 #define ARM_ALL         0x00ffffff      /* Any core + co-processor */
  93 #define CPROC_ANY       0x00ff0000      /* Any co-processor */
  94 #define FPU_ANY         0xff000000      /* Note this is ~ARM_ALL.  */
  95
  96
  97 #define FPU_FPA_EXT_V1   0x80000000     /* Base FPA instruction set.  */
  98 #define FPU_FPA_EXT_V2   0x40000000     /* LFM/SFM.                   */
  99 #define FPU_VFP_EXT_NONE 0x20000000     /* Use VFP word-ordering.     */
 100 #define FPU_VFP_EXT_V1xD 0x10000000     /* Base VFP instruction set.  */
 101 #define FPU_VFP_EXT_V1   0x08000000     /* Double-precision insns.    */
 102 #define FPU_VFP_EXT_V2   0x04000000     /* ARM10E VFPr1.              */
 103 #define FPU_NONE         0
 104
 105 #define FPU_ARCH_FPE     FPU_FPA_EXT_V1
 106 #define FPU_ARCH_FPA    (FPU_ARCH_FPE | FPU_FPA_EXT_V2)
 107
 108 #define FPU_ARCH_VFP       FPU_VFP_EXT_NONE
 109 #define FPU_ARCH_VFP_V1xD (FPU_VFP_EXT_V1xD | FPU_VFP_EXT_NONE)
 110 #define FPU_ARCH_VFP_V1   (FPU_ARCH_VFP_V1xD | FPU_VFP_EXT_V1)
 111 #define FPU_ARCH_VFP_V2   (FPU_ARCH_VFP_V1 | FPU_VFP_EXT_V2)
 112
 113 /* Types of processor to assemble for.  */
 114 #define ARM_1           ARM_ARCH_V1
 115 #define ARM_2           ARM_ARCH_V2
 116 #define ARM_3           ARM_ARCH_V2S
 117 #define ARM_250         ARM_ARCH_V2S
 118 #define ARM_6           ARM_ARCH_V3
 119 #define ARM_7           ARM_ARCH_V3
 120 #define ARM_8           ARM_ARCH_V4
 121 #define ARM_9           ARM_ARCH_V4T
 122 #define ARM_STRONG      ARM_ARCH_V4
 123 #define ARM_CPU_MASK    0x0000000f              /* XXX? */
 124
 125 #ifndef CPU_DEFAULT
 126 #if defined __XSCALE__
 127 #define CPU_DEFAULT     (ARM_ARCH_XSCALE)
 128 #else
 129 #if defined __thumb__
 130 #define CPU_DEFAULT     (ARM_ARCH_V5T)
 131 #else
 132 #define CPU_DEFAULT     ARM_ANY
 133 #endif
 134 #endif
 135 #endif
 136
 137 /* For backwards compatibility we default to the FPA.  */
 138 #ifndef FPU_DEFAULT
 139 #define FPU_DEFAULT FPU_ARCH_FPA
 140 #endif
 141
 142 #define streq(a, b)           (strcmp (a, b) == 0)
 143 #define skip_whitespace(str)  while (*(str) == ' ') ++(str)
 144
 145 static unsigned long cpu_variant;
 146 static int target_oabi = 0;
 147
 148 /* Flags stored in private area of BFD structure.  */
 149 static int uses_apcs_26      = FALSE;
 150 static int atpcs             = FALSE;
 151 static int support_interwork = FALSE;
 152 static int uses_apcs_float   = FALSE;
 153 static int pic_code          = FALSE;
 154
 155 /* Variables that we set while parsing command-line options.  Once all
 156    options have been read we re-process these values to set the real
 157    assembly flags.  */
 158 static int legacy_cpu = -1;
 159 static int legacy_fpu = -1;
 160
 161 static int mcpu_cpu_opt = -1;
 162 static int mcpu_fpu_opt = -1;
 163 static int march_cpu_opt = -1;
 164 static int march_fpu_opt = -1;
 165 static int mfpu_opt = -1;
 166
 167 /* This array holds the chars that always start a comment.  If the
 168    pre-processor is disabled, these aren't very useful.  */
 169 const char comment_chars[] = "@";
 170
 171 /* This array holds the chars that only start a comment at the beginning of
 172    a line.  If the line seems to have the form '# 123 filename'
 173    .line and .file directives will appear in the pre-processed output.  */
 174 /* Note that input_file.c hand checks for '#' at the beginning of the
 175    first line of the input file.  This is because the compiler outputs
 176    #NO_APP at the beginning of its output.  */
 177 /* Also note that comments like this one will always work.  */
 178 const char line_comment_chars[] = "#";
 179
 180 const char line_separator_chars[] = ";";
 181
 182 /* Chars that can be used to separate mant
 183    from exp in floating point numbers.  */
 184 const char EXP_CHARS[] = "eE";
 185
 186 /* Chars that mean this number is a floating point constant.  */
 187 /* As in 0f12.456  */
 188 /* or    0d1.2345e12  */
 189
 190 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 191
 192 /* Prefix characters that indicate the start of an immediate
 193    value.  */
 194 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
 195
 196 #ifdef OBJ_ELF
 197 /* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
 198 symbolS * GOT_symbol;
 199 #endif
 200
 201 /* Size of relocation record.  */
 202 const int md_reloc_size = 8;
 203
 204 /* 0: assemble for ARM,
 205    1: assemble for Thumb,
 206    2: assemble for Thumb even though target CPU does not support thumb
 207       instructions.  */
 208 static int thumb_mode = 0;
 209
 210 typedef struct arm_fix
 211 {
 212   int thumb_mode;
 213 } arm_fix_data;
 214
 215 struct arm_it
 216 {
 217   const char *  error;
 218   unsigned long instruction;
 219   int           size;
 220   struct
 221   {
 222     bfd_reloc_code_real_type type;
 223     expressionS              exp;
 224     int                      pc_rel;
 225   } reloc;
 226 };
 227
 228 struct arm_it inst;
 229
 230 enum asm_shift_index
 231 {
 232   SHIFT_LSL = 0,
 233   SHIFT_LSR,
 234   SHIFT_ASR,
 235   SHIFT_ROR,
 236   SHIFT_RRX
 237 };
 238
 239 struct asm_shift_properties
 240 {
 241   enum asm_shift_index index;
 242   unsigned long        bit_field;
 243   unsigned int         allows_0  : 1;
 244   unsigned int         allows_32 : 1;
 245 };
 246
 247 static const struct asm_shift_properties shift_properties [] =
 248 {
 249   { SHIFT_LSL, 0,    1, 0},
 250   { SHIFT_LSR, 0x20, 0, 1},
 251   { SHIFT_ASR, 0x40, 0, 1},
 252   { SHIFT_ROR, 0x60, 0, 0},
 253   { SHIFT_RRX, 0x60, 0, 0}
 254 };
 255
 256 struct asm_shift_name
 257 {
 258   const char *                        name;
 259   const struct asm_shift_properties * properties;
 260 };
 261
 262 static const struct asm_shift_name shift_names [] =
 263 {
 264   { "asl", shift_properties + SHIFT_LSL },
 265   { "lsl", shift_properties + SHIFT_LSL },
 266   { "lsr", shift_properties + SHIFT_LSR },
 267   { "asr", shift_properties + SHIFT_ASR },
 268   { "ror", shift_properties + SHIFT_ROR },
 269   { "rrx", shift_properties + SHIFT_RRX },
 270   { "ASL", shift_properties + SHIFT_LSL },
 271   { "LSL", shift_properties + SHIFT_LSL },
 272   { "LSR", shift_properties + SHIFT_LSR },
 273   { "ASR", shift_properties + SHIFT_ASR },
 274   { "ROR", shift_properties + SHIFT_ROR },
 275   { "RRX", shift_properties + SHIFT_RRX }
 276 };
 277
 278 #define NO_SHIFT_RESTRICT 1
 279 #define SHIFT_RESTRICT    0
 280
 281 #define NUM_FLOAT_VALS 8
 282
 283 const char * fp_const[] =
 284 {
 285   "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
 286 };
 287
 288 /* Number of littlenums required to hold an extended precision number.  */
 289 #define MAX_LITTLENUMS 6
 290
 291 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
 292
 293 #define FAIL    (-1)
 294 #define SUCCESS (0)
 295
 296 /* Whether a Co-processor load/store operation accepts write-back forms.  */
 297 #define CP_WB_OK 1
 298 #define CP_NO_WB 0
 299
 300 #define SUFF_S 1
 301 #define SUFF_D 2
 302 #define SUFF_E 3
 303 #define SUFF_P 4
 304
 305 #define CP_T_X   0x00008000
 306 #define CP_T_Y   0x00400000
 307 #define CP_T_Pre 0x01000000
 308 #define CP_T_UD  0x00800000
 309 #define CP_T_WB  0x00200000
 310
 311 #define CONDS_BIT        0x00100000
 312 #define LOAD_BIT         0x00100000
 313
 314 #define DOUBLE_LOAD_FLAG 0x00000001
 315
 316 struct asm_cond
 317 {
 318   const char *  template;
 319   unsigned long value;
 320 };
 321
 322 #define COND_ALWAYS 0xe0000000
 323 #define COND_MASK   0xf0000000
 324
 325 static const struct asm_cond conds[] =
 326 {
 327   {"eq", 0x00000000},
 328   {"ne", 0x10000000},
 329   {"cs", 0x20000000}, {"hs", 0x20000000},
 330   {"cc", 0x30000000}, {"ul", 0x30000000}, {"lo", 0x30000000},
 331   {"mi", 0x40000000},
 332   {"pl", 0x50000000},
 333   {"vs", 0x60000000},
 334   {"vc", 0x70000000},
 335   {"hi", 0x80000000},
 336   {"ls", 0x90000000},
 337   {"ge", 0xa0000000},
 338   {"lt", 0xb0000000},
 339   {"gt", 0xc0000000},
 340   {"le", 0xd0000000},
 341   {"al", 0xe0000000},
 342   {"nv", 0xf0000000}
 343 };
 344
 345 struct asm_psr
 346 {
 347   const char *template;
 348   bfd_boolean cpsr;
 349   unsigned long field;
 350 };
 351
 352 /* The bit that distnguishes CPSR and SPSR.  */
 353 #define SPSR_BIT   (1 << 22)
 354
 355 /* How many bits to shift the PSR_xxx bits up by.  */
 356 #define PSR_SHIFT  16
 357
 358 #define PSR_c   (1 << 0)
 359 #define PSR_x   (1 << 1)
 360 #define PSR_s   (1 << 2)
 361 #define PSR_f   (1 << 3)
 362
 363 static const struct asm_psr psrs[] =
 364 {
 365   {"CPSR",      TRUE,  PSR_c | PSR_f},
 366   {"CPSR_all",  TRUE,  PSR_c | PSR_f},
 367   {"SPSR",      FALSE, PSR_c | PSR_f},
 368   {"SPSR_all",  FALSE, PSR_c | PSR_f},
 369   {"CPSR_flg",  TRUE,  PSR_f},
 370   {"CPSR_f",    TRUE,  PSR_f},
 371   {"SPSR_flg",  FALSE, PSR_f},
 372   {"SPSR_f",    FALSE, PSR_f},
 373   {"CPSR_c",    TRUE,  PSR_c},
 374   {"CPSR_ctl",  TRUE,  PSR_c},
 375   {"SPSR_c",    FALSE, PSR_c},
 376   {"SPSR_ctl",  FALSE, PSR_c},
 377   {"CPSR_x",    TRUE,  PSR_x},
 378   {"CPSR_s",    TRUE,  PSR_s},
 379   {"SPSR_x",    FALSE, PSR_x},
 380   {"SPSR_s",    FALSE, PSR_s},
 381   /* Combinations of flags.  */
 382   {"CPSR_fs",   TRUE, PSR_f | PSR_s},
 383   {"CPSR_fx",   TRUE, PSR_f | PSR_x},
 384   {"CPSR_fc",   TRUE, PSR_f | PSR_c},
 385   {"CPSR_sf",   TRUE, PSR_s | PSR_f},
 386   {"CPSR_sx",   TRUE, PSR_s | PSR_x},
 387   {"CPSR_sc",   TRUE, PSR_s | PSR_c},
 388   {"CPSR_xf",   TRUE, PSR_x | PSR_f},
 389   {"CPSR_xs",   TRUE, PSR_x | PSR_s},
 390   {"CPSR_xc",   TRUE, PSR_x | PSR_c},
 391   {"CPSR_cf",   TRUE, PSR_c | PSR_f},
 392   {"CPSR_cs",   TRUE, PSR_c | PSR_s},
 393   {"CPSR_cx",   TRUE, PSR_c | PSR_x},
 394   {"CPSR_fsx",  TRUE, PSR_f | PSR_s | PSR_x},
 395   {"CPSR_fsc",  TRUE, PSR_f | PSR_s | PSR_c},
 396   {"CPSR_fxs",  TRUE, PSR_f | PSR_x | PSR_s},
 397   {"CPSR_fxc",  TRUE, PSR_f | PSR_x | PSR_c},
 398   {"CPSR_fcs",  TRUE, PSR_f | PSR_c | PSR_s},
 399   {"CPSR_fcx",  TRUE, PSR_f | PSR_c | PSR_x},
 400   {"CPSR_sfx",  TRUE, PSR_s | PSR_f | PSR_x},
 401   {"CPSR_sfc",  TRUE, PSR_s | PSR_f | PSR_c},
 402   {"CPSR_sxf",  TRUE, PSR_s | PSR_x | PSR_f},
 403   {"CPSR_sxc",  TRUE, PSR_s | PSR_x | PSR_c},
 404   {"CPSR_scf",  TRUE, PSR_s | PSR_c | PSR_f},
 405   {"CPSR_scx",  TRUE, PSR_s | PSR_c | PSR_x},
 406   {"CPSR_xfs",  TRUE, PSR_x | PSR_f | PSR_s},
 407   {"CPSR_xfc",  TRUE, PSR_x | PSR_f | PSR_c},
 408   {"CPSR_xsf",  TRUE, PSR_x | PSR_s | PSR_f},
 409   {"CPSR_xsc",  TRUE, PSR_x | PSR_s | PSR_c},
 410   {"CPSR_xcf",  TRUE, PSR_x | PSR_c | PSR_f},
 411   {"CPSR_xcs",  TRUE, PSR_x | PSR_c | PSR_s},
 412   {"CPSR_cfs",  TRUE, PSR_c | PSR_f | PSR_s},
 413   {"CPSR_cfx",  TRUE, PSR_c | PSR_f | PSR_x},
 414   {"CPSR_csf",  TRUE, PSR_c | PSR_s | PSR_f},
 415   {"CPSR_csx",  TRUE, PSR_c | PSR_s | PSR_x},
 416   {"CPSR_cxf",  TRUE, PSR_c | PSR_x | PSR_f},
 417   {"CPSR_cxs",  TRUE, PSR_c | PSR_x | PSR_s},
 418   {"CPSR_fsxc", TRUE, PSR_f | PSR_s | PSR_x | PSR_c},
 419   {"CPSR_fscx", TRUE, PSR_f | PSR_s | PSR_c | PSR_x},
 420   {"CPSR_fxsc", TRUE, PSR_f | PSR_x | PSR_s | PSR_c},
 421   {"CPSR_fxcs", TRUE, PSR_f | PSR_x | PSR_c | PSR_s},
 422   {"CPSR_fcsx", TRUE, PSR_f | PSR_c | PSR_s | PSR_x},
 423   {"CPSR_fcxs", TRUE, PSR_f | PSR_c | PSR_x | PSR_s},
 424   {"CPSR_sfxc", TRUE, PSR_s | PSR_f | PSR_x | PSR_c},
 425   {"CPSR_sfcx", TRUE, PSR_s | PSR_f | PSR_c | PSR_x},
 426   {"CPSR_sxfc", TRUE, PSR_s | PSR_x | PSR_f | PSR_c},
 427   {"CPSR_sxcf", TRUE, PSR_s | PSR_x | PSR_c | PSR_f},
 428   {"CPSR_scfx", TRUE, PSR_s | PSR_c | PSR_f | PSR_x},
 429   {"CPSR_scxf", TRUE, PSR_s | PSR_c | PSR_x | PSR_f},
 430   {"CPSR_xfsc", TRUE, PSR_x | PSR_f | PSR_s | PSR_c},
 431   {"CPSR_xfcs", TRUE, PSR_x | PSR_f | PSR_c | PSR_s},
 432   {"CPSR_xsfc", TRUE, PSR_x | PSR_s | PSR_f | PSR_c},
 433   {"CPSR_xscf", TRUE, PSR_x | PSR_s | PSR_c | PSR_f},
 434   {"CPSR_xcfs", TRUE, PSR_x | PSR_c | PSR_f | PSR_s},
 435   {"CPSR_xcsf", TRUE, PSR_x | PSR_c | PSR_s | PSR_f},
 436   {"CPSR_cfsx", TRUE, PSR_c | PSR_f | PSR_s | PSR_x},
 437   {"CPSR_cfxs", TRUE, PSR_c | PSR_f | PSR_x | PSR_s},
 438   {"CPSR_csfx", TRUE, PSR_c | PSR_s | PSR_f | PSR_x},
 439   {"CPSR_csxf", TRUE, PSR_c | PSR_s | PSR_x | PSR_f},
 440   {"CPSR_cxfs", TRUE, PSR_c | PSR_x | PSR_f | PSR_s},
 441   {"CPSR_cxsf", TRUE, PSR_c | PSR_x | PSR_s | PSR_f},
 442   {"SPSR_fs",   FALSE, PSR_f | PSR_s},
 443   {"SPSR_fx",   FALSE, PSR_f | PSR_x},
 444   {"SPSR_fc",   FALSE, PSR_f | PSR_c},
 445   {"SPSR_sf",   FALSE, PSR_s | PSR_f},
 446   {"SPSR_sx",   FALSE, PSR_s | PSR_x},
 447   {"SPSR_sc",   FALSE, PSR_s | PSR_c},
 448   {"SPSR_xf",   FALSE, PSR_x | PSR_f},
 449   {"SPSR_xs",   FALSE, PSR_x | PSR_s},
 450   {"SPSR_xc",   FALSE, PSR_x | PSR_c},
 451   {"SPSR_cf",   FALSE, PSR_c | PSR_f},
 452   {"SPSR_cs",   FALSE, PSR_c | PSR_s},
 453   {"SPSR_cx",   FALSE, PSR_c | PSR_x},
 454   {"SPSR_fsx",  FALSE, PSR_f | PSR_s | PSR_x},
 455   {"SPSR_fsc",  FALSE, PSR_f | PSR_s | PSR_c},
 456   {"SPSR_fxs",  FALSE, PSR_f | PSR_x | PSR_s},
 457   {"SPSR_fxc",  FALSE, PSR_f | PSR_x | PSR_c},
 458   {"SPSR_fcs",  FALSE, PSR_f | PSR_c | PSR_s},
 459   {"SPSR_fcx",  FALSE, PSR_f | PSR_c | PSR_x},
 460   {"SPSR_sfx",  FALSE, PSR_s | PSR_f | PSR_x},
 461   {"SPSR_sfc",  FALSE, PSR_s | PSR_f | PSR_c},
 462   {"SPSR_sxf",  FALSE, PSR_s | PSR_x | PSR_f},
 463   {"SPSR_sxc",  FALSE, PSR_s | PSR_x | PSR_c},
 464   {"SPSR_scf",  FALSE, PSR_s | PSR_c | PSR_f},
 465   {"SPSR_scx",  FALSE, PSR_s | PSR_c | PSR_x},
 466   {"SPSR_xfs",  FALSE, PSR_x | PSR_f | PSR_s},
 467   {"SPSR_xfc",  FALSE, PSR_x | PSR_f | PSR_c},
 468   {"SPSR_xsf",  FALSE, PSR_x | PSR_s | PSR_f},
 469   {"SPSR_xsc",  FALSE, PSR_x | PSR_s | PSR_c},
 470   {"SPSR_xcf",  FALSE, PSR_x | PSR_c | PSR_f},
 471   {"SPSR_xcs",  FALSE, PSR_x | PSR_c | PSR_s},
 472   {"SPSR_cfs",  FALSE, PSR_c | PSR_f | PSR_s},
 473   {"SPSR_cfx",  FALSE, PSR_c | PSR_f | PSR_x},
 474   {"SPSR_csf",  FALSE, PSR_c | PSR_s | PSR_f},
 475   {"SPSR_csx",  FALSE, PSR_c | PSR_s | PSR_x},
 476   {"SPSR_cxf",  FALSE, PSR_c | PSR_x | PSR_f},
 477   {"SPSR_cxs",  FALSE, PSR_c | PSR_x | PSR_s},
 478   {"SPSR_fsxc", FALSE, PSR_f | PSR_s | PSR_x | PSR_c},
 479   {"SPSR_fscx", FALSE, PSR_f | PSR_s | PSR_c | PSR_x},
 480   {"SPSR_fxsc", FALSE, PSR_f | PSR_x | PSR_s | PSR_c},
 481   {"SPSR_fxcs", FALSE, PSR_f | PSR_x | PSR_c | PSR_s},
 482   {"SPSR_fcsx", FALSE, PSR_f | PSR_c | PSR_s | PSR_x},
 483   {"SPSR_fcxs", FALSE, PSR_f | PSR_c | PSR_x | PSR_s},
 484   {"SPSR_sfxc", FALSE, PSR_s | PSR_f | PSR_x | PSR_c},
 485   {"SPSR_sfcx", FALSE, PSR_s | PSR_f | PSR_c | PSR_x},
 486   {"SPSR_sxfc", FALSE, PSR_s | PSR_x | PSR_f | PSR_c},
 487   {"SPSR_sxcf", FALSE, PSR_s | PSR_x | PSR_c | PSR_f},
 488   {"SPSR_scfx", FALSE, PSR_s | PSR_c | PSR_f | PSR_x},
 489   {"SPSR_scxf", FALSE, PSR_s | PSR_c | PSR_x | PSR_f},
 490   {"SPSR_xfsc", FALSE, PSR_x | PSR_f | PSR_s | PSR_c},
 491   {"SPSR_xfcs", FALSE, PSR_x | PSR_f | PSR_c | PSR_s},
 492   {"SPSR_xsfc", FALSE, PSR_x | PSR_s | PSR_f | PSR_c},
 493   {"SPSR_xscf", FALSE, PSR_x | PSR_s | PSR_c | PSR_f},
 494   {"SPSR_xcfs", FALSE, PSR_x | PSR_c | PSR_f | PSR_s},
 495   {"SPSR_xcsf", FALSE, PSR_x | PSR_c | PSR_s | PSR_f},
 496   {"SPSR_cfsx", FALSE, PSR_c | PSR_f | PSR_s | PSR_x},
 497   {"SPSR_cfxs", FALSE, PSR_c | PSR_f | PSR_x | PSR_s},
 498   {"SPSR_csfx", FALSE, PSR_c | PSR_s | PSR_f | PSR_x},
 499   {"SPSR_csxf", FALSE, PSR_c | PSR_s | PSR_x | PSR_f},
 500   {"SPSR_cxfs", FALSE, PSR_c | PSR_x | PSR_f | PSR_s},
 501   {"SPSR_cxsf", FALSE, PSR_c | PSR_x | PSR_s | PSR_f},
 502 };
 503
 504 enum wreg_type
 505   {
 506     IWMMXT_REG_WR = 0,
 507     IWMMXT_REG_WC = 1,
 508     IWMMXT_REG_WR_OR_WC = 2,
 509     IWMMXT_REG_WCG
 510   };
 511
 512 enum iwmmxt_insn_type
 513 {
 514   check_rd,
 515   check_wr,
 516   check_wrwr,
 517   check_wrwrwr,
 518   check_wrwrwcg,
 519   check_tbcst,
 520   check_tmovmsk,
 521   check_tmia,
 522   check_tmcrr,
 523   check_tmrrc,
 524   check_tmcr,
 525   check_tmrc,
 526   check_tinsr,
 527   check_textrc,
 528   check_waligni,
 529   check_textrm,
 530   check_wshufh
 531 };
 532
 533 enum vfp_dp_reg_pos
 534 {
 535   VFP_REG_Dd, VFP_REG_Dm, VFP_REG_Dn
 536 };
 537
 538 enum vfp_sp_reg_pos
 539 {
 540   VFP_REG_Sd, VFP_REG_Sm, VFP_REG_Sn
 541 };
 542
 543 enum vfp_ldstm_type
 544 {
 545   VFP_LDSTMIA, VFP_LDSTMDB, VFP_LDSTMIAX, VFP_LDSTMDBX
 546 };
 547
 548 /* VFP system registers.  */
 549 struct vfp_reg
 550 {
 551   const char *name;
 552   unsigned long regno;
 553 };
 554
 555 static const struct vfp_reg vfp_regs[] =
 556 {
 557   {"fpsid", 0x00000000},
 558   {"FPSID", 0x00000000},
 559   {"fpscr", 0x00010000},
 560   {"FPSCR", 0x00010000},
 561   {"fpexc", 0x00080000},
 562   {"FPEXC", 0x00080000}
 563 };
 564
 565 /* Structure for a hash table entry for a register.  */
 566 struct reg_entry
 567 {
 568   const char * name;
 569   int          number;
 570 };
 571
 572 /* Some well known registers that we refer to directly elsewhere.  */
 573 #define REG_SP  13
 574 #define REG_LR  14
 575 #define REG_PC  15
 576
 577 #define wr_register(reg)  ((reg ^ WR_PREFIX) >= 0 && (reg ^ WR_PREFIX) <= 15)
 578 #define wc_register(reg)  ((reg ^ WC_PREFIX) >= 0 && (reg ^ WC_PREFIX) <= 15)
 579 #define wcg_register(reg) ((reg ^ WC_PREFIX) >= 8 && (reg ^ WC_PREFIX) <= 11)
 580
 581 /* These are the standard names.  Users can add aliases with .req.  */
 582 /* Integer Register Numbers.  */
 583 static const struct reg_entry rn_table[] =
 584 {
 585   {"r0",  0},  {"r1",  1},      {"r2",  2},      {"r3",  3},
 586   {"r4",  4},  {"r5",  5},      {"r6",  6},      {"r7",  7},
 587   {"r8",  8},  {"r9",  9},      {"r10", 10},     {"r11", 11},
 588   {"r12", 12}, {"r13", REG_SP}, {"r14", REG_LR}, {"r15", REG_PC},
 589   /* ATPCS Synonyms.  */
 590   {"a1",  0},  {"a2",  1},      {"a3",  2},      {"a4",  3},
 591   {"v1",  4},  {"v2",  5},      {"v3",  6},      {"v4",  7},
 592   {"v5",  8},  {"v6",  9},      {"v7",  10},     {"v8",  11},
 593   /* Well-known aliases.  */
 594                                                  {"wr",  7},
 595                {"sb",  9},      {"sl",  10},     {"fp",  11},
 596   {"ip",  12}, {"sp",  REG_SP}, {"lr",  REG_LR}, {"pc",  REG_PC},
 597   {NULL, 0}
 598 };
 599
 600 #define WR_PREFIX 0x200
 601 #define WC_PREFIX 0x400
 602
 603 static const struct reg_entry iwmmxt_table[] =
 604 {
 605   /* Intel Wireless MMX technology register names.  */
 606   {  "wr0", 0x0 | WR_PREFIX},   {"wr1", 0x1 | WR_PREFIX},
 607   {  "wr2", 0x2 | WR_PREFIX},   {"wr3", 0x3 | WR_PREFIX},
 608   {  "wr4", 0x4 | WR_PREFIX},   {"wr5", 0x5 | WR_PREFIX},
 609   {  "wr6", 0x6 | WR_PREFIX},   {"wr7", 0x7 | WR_PREFIX},
 610   {  "wr8", 0x8 | WR_PREFIX},   {"wr9", 0x9 | WR_PREFIX},
 611   { "wr10", 0xa | WR_PREFIX},  {"wr11", 0xb | WR_PREFIX},
 612   { "wr12", 0xc | WR_PREFIX},  {"wr13", 0xd | WR_PREFIX},
 613   { "wr14", 0xe | WR_PREFIX},  {"wr15", 0xf | WR_PREFIX},
 614   { "wcid", 0x0 | WC_PREFIX},  {"wcon", 0x1 | WC_PREFIX},
 615   {"wcssf", 0x2 | WC_PREFIX}, {"wcasf", 0x3 | WC_PREFIX},
 616   {"wcgr0", 0x8 | WC_PREFIX}, {"wcgr1", 0x9 | WC_PREFIX},
 617   {"wcgr2", 0xa | WC_PREFIX}, {"wcgr3", 0xb | WC_PREFIX},
 618
 619   {  "wR0", 0x0 | WR_PREFIX},   {"wR1", 0x1 | WR_PREFIX},
 620   {  "wR2", 0x2 | WR_PREFIX},   {"wR3", 0x3 | WR_PREFIX},
 621   {  "wR4", 0x4 | WR_PREFIX},   {"wR5", 0x5 | WR_PREFIX},
 622   {  "wR6", 0x6 | WR_PREFIX},   {"wR7", 0x7 | WR_PREFIX},
 623   {  "wR8", 0x8 | WR_PREFIX},   {"wR9", 0x9 | WR_PREFIX},
 624   { "wR10", 0xa | WR_PREFIX},  {"wR11", 0xb | WR_PREFIX},
 625   { "wR12", 0xc | WR_PREFIX},  {"wR13", 0xd | WR_PREFIX},
 626   { "wR14", 0xe | WR_PREFIX},  {"wR15", 0xf | WR_PREFIX},
 627   { "wCID", 0x0 | WC_PREFIX},  {"wCon", 0x1 | WC_PREFIX},
 628   {"wCSSF", 0x2 | WC_PREFIX}, {"wCASF", 0x3 | WC_PREFIX},
 629   {"wCGR0", 0x8 | WC_PREFIX}, {"wCGR1", 0x9 | WC_PREFIX},
 630   {"wCGR2", 0xa | WC_PREFIX}, {"wCGR3", 0xb | WC_PREFIX},
 631   {NULL, 0}
 632 };
 633
 634 /* Co-processor Numbers.  */
 635 static const struct reg_entry cp_table[] =
 636 {
 637   {"p0",  0},  {"p1",  1},  {"p2",  2},  {"p3", 3},
 638   {"p4",  4},  {"p5",  5},  {"p6",  6},  {"p7", 7},
 639   {"p8",  8},  {"p9",  9},  {"p10", 10}, {"p11", 11},
 640   {"p12", 12}, {"p13", 13}, {"p14", 14}, {"p15", 15},
 641   {NULL, 0}
 642 };
 643
 644 /* Co-processor Register Numbers.  */
 645 static const struct reg_entry cn_table[] =
 646 {
 647   {"c0",   0},  {"c1",   1},  {"c2",   2},  {"c3",   3},
 648   {"c4",   4},  {"c5",   5},  {"c6",   6},  {"c7",   7},
 649   {"c8",   8},  {"c9",   9},  {"c10",  10}, {"c11",  11},
 650   {"c12",  12}, {"c13",  13}, {"c14",  14}, {"c15",  15},
 651   /* Not really valid, but kept for back-wards compatibility.  */
 652   {"cr0",  0},  {"cr1",  1},  {"cr2",  2},  {"cr3",  3},
 653   {"cr4",  4},  {"cr5",  5},  {"cr6",  6},  {"cr7",  7},
 654   {"cr8",  8},  {"cr9",  9},  {"cr10", 10}, {"cr11", 11},
 655   {"cr12", 12}, {"cr13", 13}, {"cr14", 14}, {"cr15", 15},
 656   {NULL, 0}
 657 };
 658
 659 /* FPA Registers.  */
 660 static const struct reg_entry fn_table[] =
 661 {
 662   {"f0", 0},   {"f1", 1},   {"f2", 2},   {"f3", 3},
 663   {"f4", 4},   {"f5", 5},   {"f6", 6},   {"f7", 7},
 664   {NULL, 0}
 665 };
 666
 667 /* VFP SP Registers.  */
 668 static const struct reg_entry sn_table[] =
 669 {
 670   {"s0",  0},  {"s1",  1},  {"s2",  2},  {"s3", 3},
 671   {"s4",  4},  {"s5",  5},  {"s6",  6},  {"s7", 7},
 672   {"s8",  8},  {"s9",  9},  {"s10", 10}, {"s11", 11},
 673   {"s12", 12}, {"s13", 13}, {"s14", 14}, {"s15", 15},
 674   {"s16", 16}, {"s17", 17}, {"s18", 18}, {"s19", 19},
 675   {"s20", 20}, {"s21", 21}, {"s22", 22}, {"s23", 23},
 676   {"s24", 24}, {"s25", 25}, {"s26", 26}, {"s27", 27},
 677   {"s28", 28}, {"s29", 29}, {"s30", 30}, {"s31", 31},
 678   {NULL, 0}
 679 };
 680
 681 /* VFP DP Registers.  */
 682 static const struct reg_entry dn_table[] =
 683 {
 684   {"d0",  0},  {"d1",  1},  {"d2",  2},  {"d3", 3},
 685   {"d4",  4},  {"d5",  5},  {"d6",  6},  {"d7", 7},
 686   {"d8",  8},  {"d9",  9},  {"d10", 10}, {"d11", 11},
 687   {"d12", 12}, {"d13", 13}, {"d14", 14}, {"d15", 15},
 688   {NULL, 0}
 689 };
 690
 691 /* Maverick DSP coprocessor registers.  */
 692 static const struct reg_entry mav_mvf_table[] =
 693 {
 694   {"mvf0",  0},  {"mvf1",  1},  {"mvf2",  2},  {"mvf3",  3},
 695   {"mvf4",  4},  {"mvf5",  5},  {"mvf6",  6},  {"mvf7",  7},
 696   {"mvf8",  8},  {"mvf9",  9},  {"mvf10", 10}, {"mvf11", 11},
 697   {"mvf12", 12}, {"mvf13", 13}, {"mvf14", 14}, {"mvf15", 15},
 698   {NULL, 0}
 699 };
 700
 701 static const struct reg_entry mav_mvd_table[] =
 702 {
 703   {"mvd0",  0},  {"mvd1",  1},  {"mvd2",  2},  {"mvd3",  3},
 704   {"mvd4",  4},  {"mvd5",  5},  {"mvd6",  6},  {"mvd7",  7},
 705   {"mvd8",  8},  {"mvd9",  9},  {"mvd10", 10}, {"mvd11", 11},
 706   {"mvd12", 12}, {"mvd13", 13}, {"mvd14", 14}, {"mvd15", 15},
 707   {NULL, 0}
 708 };
 709
 710 static const struct reg_entry mav_mvfx_table[] =
 711 {
 712   {"mvfx0",  0},  {"mvfx1",  1},  {"mvfx2",  2},  {"mvfx3",  3},
 713   {"mvfx4",  4},  {"mvfx5",  5},  {"mvfx6",  6},  {"mvfx7",  7},
 714   {"mvfx8",  8},  {"mvfx9",  9},  {"mvfx10", 10}, {"mvfx11", 11},
 715   {"mvfx12", 12}, {"mvfx13", 13}, {"mvfx14", 14}, {"mvfx15", 15},
 716   {NULL, 0}
 717 };
 718
 719 static const struct reg_entry mav_mvdx_table[] =
 720 {
 721   {"mvdx0",  0},  {"mvdx1",  1},  {"mvdx2",  2},  {"mvdx3",  3},
 722   {"mvdx4",  4},  {"mvdx5",  5},  {"mvdx6",  6},  {"mvdx7",  7},
 723   {"mvdx8",  8},  {"mvdx9",  9},  {"mvdx10", 10}, {"mvdx11", 11},
 724   {"mvdx12", 12}, {"mvdx13", 13}, {"mvdx14", 14}, {"mvdx15", 15},
 725   {NULL, 0}
 726 };
 727
 728 static const struct reg_entry mav_mvax_table[] =
 729 {
 730   {"mvax0", 0}, {"mvax1", 1}, {"mvax2", 2}, {"mvax3", 3},
 731   {NULL, 0}
 732 };
 733
 734 static const struct reg_entry mav_dspsc_table[] =
 735 {
 736   {"dspsc", 0},
 737   {NULL, 0}
 738 };
 739
 740 struct reg_map
 741 {
 742   const struct reg_entry *names;
 743   int max_regno;
 744   struct hash_control *htab;
 745   const char *expected;
 746 };
 747
 748 struct reg_map all_reg_maps[] =
 749 {
 750   {rn_table,        15, NULL, N_("ARM register expected")},
 751   {cp_table,        15, NULL, N_("bad or missing co-processor number")},
 752   {cn_table,        15, NULL, N_("co-processor register expected")},
 753   {fn_table,         7, NULL, N_("FPA register expected")},
 754   {sn_table,        31, NULL, N_("VFP single precision register expected")},
 755   {dn_table,        15, NULL, N_("VFP double precision register expected")},
 756   {mav_mvf_table,   15, NULL, N_("Maverick MVF register expected")},
 757   {mav_mvd_table,   15, NULL, N_("Maverick MVD register expected")},
 758   {mav_mvfx_table,  15, NULL, N_("Maverick MVFX register expected")},
 759   {mav_mvdx_table,  15, NULL, N_("Maverick MVFX register expected")},
 760   {mav_mvax_table,   3, NULL, N_("Maverick MVAX register expected")},
 761   {mav_dspsc_table,  0, NULL, N_("Maverick DSPSC register expected")},
 762   {iwmmxt_table,    23, NULL, N_("Intel Wireless MMX technology register expected")},
 763 };
 764
 765 /* Enumeration matching entries in table above.  */
 766 enum arm_reg_type
 767 {
 768   REG_TYPE_RN = 0,
 769 #define REG_TYPE_FIRST REG_TYPE_RN
 770   REG_TYPE_CP = 1,
 771   REG_TYPE_CN = 2,
 772   REG_TYPE_FN = 3,
 773   REG_TYPE_SN = 4,
 774   REG_TYPE_DN = 5,
 775   REG_TYPE_MVF = 6,
 776   REG_TYPE_MVD = 7,
 777   REG_TYPE_MVFX = 8,
 778   REG_TYPE_MVDX = 9,
 779   REG_TYPE_MVAX = 10,
 780   REG_TYPE_DSPSC = 11,
 781   REG_TYPE_IWMMXT = 12,
 782
 783   REG_TYPE_MAX = 13
 784 };
 785
 786 /* Functions called by parser.  */
 787 /* ARM instructions.  */
 788 static void do_arit             PARAMS ((char *));
 789 static void do_cmp              PARAMS ((char *));
 790 static void do_mov              PARAMS ((char *));
 791 static void do_ldst             PARAMS ((char *));
 792 static void do_ldstt            PARAMS ((char *));
 793 static void do_ldmstm           PARAMS ((char *));
 794 static void do_branch           PARAMS ((char *));
 795 static void do_swi              PARAMS ((char *));
 796
 797 /* Pseudo Op codes.  */
 798 static void do_adr              PARAMS ((char *));
 799 static void do_adrl             PARAMS ((char *));
 800 static void do_empty            PARAMS ((char *));
 801
 802 /* ARM v2.  */
 803 static void do_mul              PARAMS ((char *));
 804 static void do_mla              PARAMS ((char *));
 805
 806 /* ARM v2S.  */
 807 static void do_swap             PARAMS ((char *));
 808
 809 /* ARM v3.  */
 810 static void do_msr              PARAMS ((char *));
 811 static void do_mrs              PARAMS ((char *));
 812
 813 /* ARM v3M.  */
 814 static void do_mull             PARAMS ((char *));
 815
 816 /* ARM v4.  */
 817 static void do_ldstv4           PARAMS ((char *));
 818
 819 /* ARM v4T.  */
 820 static void do_bx               PARAMS ((char *));
 821
 822 /* ARM v5T.  */
 823 static void do_blx              PARAMS ((char *));
 824 static void do_bkpt             PARAMS ((char *));
 825 static void do_clz              PARAMS ((char *));
 826 static void do_lstc2            PARAMS ((char *));
 827 static void do_cdp2             PARAMS ((char *));
 828 static void do_co_reg2          PARAMS ((char *));
 829
 830 /* ARM v5TExP.  */
 831 static void do_smla             PARAMS ((char *));
 832 static void do_smlal            PARAMS ((char *));
 833 static void do_smul             PARAMS ((char *));
 834 static void do_qadd             PARAMS ((char *));
 835
 836 /* ARM v5TE.  */
 837 static void do_pld              PARAMS ((char *));
 838 static void do_ldrd             PARAMS ((char *));
 839 static void do_co_reg2c         PARAMS ((char *));
 840
 841 /* ARM v5TEJ.  */
 842 static void do_bxj              PARAMS ((char *));
 843
 844 /* Coprocessor Instructions.  */
 845 static void do_cdp              PARAMS ((char *));
 846 static void do_lstc             PARAMS ((char *));
 847 static void do_co_reg           PARAMS ((char *));
 848
 849 /* FPA instructions.  */
 850 static void do_fpa_ctrl         PARAMS ((char *));
 851 static void do_fpa_ldst         PARAMS ((char *));
 852 static void do_fpa_ldmstm       PARAMS ((char *));
 853 static void do_fpa_dyadic       PARAMS ((char *));
 854 static void do_fpa_monadic      PARAMS ((char *));
 855 static void do_fpa_cmp          PARAMS ((char *));
 856 static void do_fpa_from_reg     PARAMS ((char *));
 857 static void do_fpa_to_reg       PARAMS ((char *));
 858
 859 /* VFP instructions.  */
 860 static void do_vfp_sp_monadic   PARAMS ((char *));
 861 static void do_vfp_dp_monadic   PARAMS ((char *));
 862 static void do_vfp_sp_dyadic    PARAMS ((char *));
 863 static void do_vfp_dp_dyadic    PARAMS ((char *));
 864 static void do_vfp_reg_from_sp  PARAMS ((char *));
 865 static void do_vfp_sp_from_reg  PARAMS ((char *));
 866 static void do_vfp_sp_reg2      PARAMS ((char *));
 867 static void do_vfp_reg_from_dp  PARAMS ((char *));
 868 static void do_vfp_reg2_from_dp PARAMS ((char *));
 869 static void do_vfp_dp_from_reg  PARAMS ((char *));
 870 static void do_vfp_dp_from_reg2 PARAMS ((char *));
 871 static void do_vfp_reg_from_ctrl PARAMS ((char *));
 872 static void do_vfp_ctrl_from_reg PARAMS ((char *));
 873 static void do_vfp_sp_ldst      PARAMS ((char *));
 874 static void do_vfp_dp_ldst      PARAMS ((char *));
 875 static void do_vfp_sp_ldstmia   PARAMS ((char *));
 876 static void do_vfp_sp_ldstmdb   PARAMS ((char *));
 877 static void do_vfp_dp_ldstmia   PARAMS ((char *));
 878 static void do_vfp_dp_ldstmdb   PARAMS ((char *));
 879 static void do_vfp_xp_ldstmia   PARAMS ((char *));
 880 static void do_vfp_xp_ldstmdb   PARAMS ((char *));
 881 static void do_vfp_sp_compare_z PARAMS ((char *));
 882 static void do_vfp_dp_compare_z PARAMS ((char *));
 883 static void do_vfp_dp_sp_cvt    PARAMS ((char *));
 884 static void do_vfp_sp_dp_cvt    PARAMS ((char *));
 885
 886 /* XScale.  */
 887 static void do_xsc_mia          PARAMS ((char *));
 888 static void do_xsc_mar          PARAMS ((char *));
 889 static void do_xsc_mra          PARAMS ((char *));
 890
 891 /* Maverick.  */
 892 static void do_mav_binops       PARAMS ((char *, int, enum arm_reg_type,
 893                                          enum arm_reg_type));
 894 static void do_mav_binops_1a    PARAMS ((char *));
 895 static void do_mav_binops_1b    PARAMS ((char *));
 896 static void do_mav_binops_1c    PARAMS ((char *));
 897 static void do_mav_binops_1d    PARAMS ((char *));
 898 static void do_mav_binops_1e    PARAMS ((char *));
 899 static void do_mav_binops_1f    PARAMS ((char *));
 900 static void do_mav_binops_1g    PARAMS ((char *));
 901 static void do_mav_binops_1h    PARAMS ((char *));
 902 static void do_mav_binops_1i    PARAMS ((char *));
 903 static void do_mav_binops_1j    PARAMS ((char *));
 904 static void do_mav_binops_1k    PARAMS ((char *));
 905 static void do_mav_binops_1l    PARAMS ((char *));
 906 static void do_mav_binops_1m    PARAMS ((char *));
 907 static void do_mav_binops_1n    PARAMS ((char *));
 908 static void do_mav_binops_1o    PARAMS ((char *));
 909 static void do_mav_binops_2a    PARAMS ((char *));
 910 static void do_mav_binops_2b    PARAMS ((char *));
 911 static void do_mav_binops_2c    PARAMS ((char *));
 912 static void do_mav_binops_3a    PARAMS ((char *));
 913 static void do_mav_binops_3b    PARAMS ((char *));
 914 static void do_mav_binops_3c    PARAMS ((char *));
 915 static void do_mav_binops_3d    PARAMS ((char *));
 916 static void do_mav_triple       PARAMS ((char *, int, enum arm_reg_type,
 917                                          enum arm_reg_type,
 918                                          enum arm_reg_type));
 919 static void do_mav_triple_4a    PARAMS ((char *));
 920 static void do_mav_triple_4b    PARAMS ((char *));
 921 static void do_mav_triple_5a    PARAMS ((char *));
 922 static void do_mav_triple_5b    PARAMS ((char *));
 923 static void do_mav_triple_5c    PARAMS ((char *));
 924 static void do_mav_triple_5d    PARAMS ((char *));
 925 static void do_mav_triple_5e    PARAMS ((char *));
 926 static void do_mav_triple_5f    PARAMS ((char *));
 927 static void do_mav_triple_5g    PARAMS ((char *));
 928 static void do_mav_triple_5h    PARAMS ((char *));
 929 static void do_mav_quad         PARAMS ((char *, int, enum arm_reg_type,
 930                                          enum arm_reg_type,
 931                                          enum arm_reg_type,
 932                                          enum arm_reg_type));
 933 static void do_mav_quad_6a      PARAMS ((char *));
 934 static void do_mav_quad_6b      PARAMS ((char *));
 935 static void do_mav_dspsc_1      PARAMS ((char *));
 936 static void do_mav_dspsc_2      PARAMS ((char *));
 937 static void do_mav_shift        PARAMS ((char *, enum arm_reg_type,
 938                                          enum arm_reg_type));
 939 static void do_mav_shift_1      PARAMS ((char *));
 940 static void do_mav_shift_2      PARAMS ((char *));
 941 static void do_mav_ldst         PARAMS ((char *, enum arm_reg_type));
 942 static void do_mav_ldst_1       PARAMS ((char *));
 943 static void do_mav_ldst_2       PARAMS ((char *));
 944 static void do_mav_ldst_3       PARAMS ((char *));
 945 static void do_mav_ldst_4       PARAMS ((char *));
 946
 947 static int mav_reg_required_here        PARAMS ((char **, int,
 948                                                  enum arm_reg_type));
 949 static int mav_parse_offset     PARAMS ((char **, int *));
 950
 951 static void fix_new_arm         PARAMS ((fragS *, int, short, expressionS *,
 952                                          int, int));
 953 static int arm_reg_parse        PARAMS ((char **, struct hash_control *));
 954 static enum arm_reg_type arm_reg_parse_any PARAMS ((char *));
 955 static const struct asm_psr * arm_psr_parse PARAMS ((char **));
 956 static void symbol_locate       PARAMS ((symbolS *, const char *, segT, valueT,
 957                                          fragS *));
 958 static int add_to_lit_pool      PARAMS ((void));
 959 static unsigned validate_immediate PARAMS ((unsigned));
 960 static unsigned validate_immediate_twopart PARAMS ((unsigned int,
 961                                                     unsigned int *));
 962 static int validate_offset_imm  PARAMS ((unsigned int, int));
 963 static void opcode_select       PARAMS ((int));
 964 static void end_of_line         PARAMS ((char *));
 965 static int reg_required_here    PARAMS ((char **, int));
 966 static int psr_required_here    PARAMS ((char **));
 967 static int co_proc_number       PARAMS ((char **));
 968 static int cp_opc_expr          PARAMS ((char **, int, int));
 969 static int cp_reg_required_here PARAMS ((char **, int));
 970 static int fp_reg_required_here PARAMS ((char **, int));
 971 static int vfp_sp_reg_required_here PARAMS ((char **, enum vfp_sp_reg_pos));
 972 static int vfp_dp_reg_required_here PARAMS ((char **, enum vfp_dp_reg_pos));
 973 static void vfp_sp_ldstm        PARAMS ((char *, enum vfp_ldstm_type));
 974 static void vfp_dp_ldstm        PARAMS ((char *, enum vfp_ldstm_type));
 975 static long vfp_sp_reg_list     PARAMS ((char **, enum vfp_sp_reg_pos));
 976 static long vfp_dp_reg_list     PARAMS ((char **));
 977 static int vfp_psr_required_here PARAMS ((char **str));
 978 static const struct vfp_reg *vfp_psr_parse PARAMS ((char **str));
 979 static int cp_address_offset    PARAMS ((char **));
 980 static int cp_address_required_here     PARAMS ((char **, int));
 981 static int my_get_float_expression      PARAMS ((char **));
 982 static int skip_past_comma      PARAMS ((char **));
 983 static int walk_no_bignums      PARAMS ((symbolS *));
 984 static int negate_data_op       PARAMS ((unsigned long *, unsigned long));
 985 static int data_op2             PARAMS ((char **));
 986 static int fp_op2               PARAMS ((char **));
 987 static long reg_list            PARAMS ((char **));
 988 static void thumb_load_store    PARAMS ((char *, int, int));
 989 static int decode_shift         PARAMS ((char **, int));
 990 static int ldst_extend          PARAMS ((char **));
 991 static int ldst_extend_v4               PARAMS ((char **));
 992 static void thumb_add_sub       PARAMS ((char *, int));
 993 static void insert_reg          PARAMS ((const struct reg_entry *,
 994                                          struct hash_control *));
 995 static void thumb_shift         PARAMS ((char *, int));
 996 static void thumb_mov_compare   PARAMS ((char *, int));
 997 static void build_arm_ops_hsh   PARAMS ((void));
 998 static void set_constant_flonums        PARAMS ((void));
 999 static valueT md_chars_to_number        PARAMS ((char *, int));
1000 static void build_reg_hsh       PARAMS ((struct reg_map *));
1001 static void insert_reg_alias    PARAMS ((char *, int, struct hash_control *));
1002 static int create_register_alias        PARAMS ((char *, char *));
1003 static void output_inst         PARAMS ((const char *));
1004 static int accum0_required_here PARAMS ((char **));
1005 static int ld_mode_required_here PARAMS ((char **));
1006 static void do_branch25         PARAMS ((char *));
1007 static symbolS * find_real_start PARAMS ((symbolS *));
1008 #ifdef OBJ_ELF
1009 static bfd_reloc_code_real_type arm_parse_reloc PARAMS ((void));
1010 #endif
1011
1012 static int wreg_required_here   PARAMS ((char **, int, enum wreg_type));
1013 static void do_iwmmxt_byte_addr PARAMS ((char *));
1014 static void do_iwmmxt_tandc     PARAMS ((char *));
1015 static void do_iwmmxt_tbcst     PARAMS ((char *));
1016 static void do_iwmmxt_textrc    PARAMS ((char *));
1017 static void do_iwmmxt_textrm    PARAMS ((char *));
1018 static void do_iwmmxt_tinsr     PARAMS ((char *));
1019 static void do_iwmmxt_tmcr      PARAMS ((char *));
1020 static void do_iwmmxt_tmcrr     PARAMS ((char *));
1021 static void do_iwmmxt_tmia      PARAMS ((char *));
1022 static void do_iwmmxt_tmovmsk   PARAMS ((char *));
1023 static void do_iwmmxt_tmrc      PARAMS ((char *));
1024 static void do_iwmmxt_tmrrc     PARAMS ((char *));
1025 static void do_iwmmxt_torc      PARAMS ((char *));
1026 static void do_iwmmxt_waligni   PARAMS ((char *));
1027 static void do_iwmmxt_wmov      PARAMS ((char *));
1028 static void do_iwmmxt_word_addr PARAMS ((char *));
1029 static void do_iwmmxt_wrwr      PARAMS ((char *));
1030 static void do_iwmmxt_wrwrwcg   PARAMS ((char *));
1031 static void do_iwmmxt_wrwrwr    PARAMS ((char *));
1032 static void do_iwmmxt_wshufh    PARAMS ((char *));
1033 static void do_iwmmxt_wzero     PARAMS ((char *));
1034 static int cp_byte_address_offset         PARAMS ((char **));
1035 static int cp_byte_address_required_here  PARAMS ((char **));
1036
1037 /* ARM instructions take 4bytes in the object file, Thumb instructions
1038    take 2:  */
1039 #define INSN_SIZE       4
1040
1041 /* "INSN<cond> X,Y" where X:bit12, Y:bit16.  */
1042 #define MAV_MODE1       0x100c
1043
1044 /* "INSN<cond> X,Y" where X:bit16, Y:bit12.  */
1045 #define MAV_MODE2       0x0c10
1046
1047 /* "INSN<cond> X,Y" where X:0, Y:bit16.  */
1048 #define MAV_MODE3       0x1000
1049
1050 /* "INSN<cond> X,Y,Z" where X:16, Y:0, Z:12.  */
1051 #define MAV_MODE4       0x0c0010
1052
1053 /* "INSN<cond> X,Y,Z" where X:12, Y:16, Z:0.  */
1054 #define MAV_MODE5       0x00100c
1055
1056 /* "INSN<cond> W,X,Y,Z" where W:5, X:12, Y:16, Z:0.  */
1057 #define MAV_MODE6       0x00100c05
1058
1059 struct asm_opcode
1060 {
1061   /* Basic string to match.  */
1062   const char * template;
1063
1064   /* Basic instruction code.  */
1065   unsigned long value;
1066
1067   /* Offset into the template where the condition code (if any) will be.
1068      If zero, then the instruction is never conditional.  */
1069   unsigned cond_offset;
1070
1071   /* Which architecture variant provides this instruction.  */
1072   unsigned long variant;
1073
1074   /* Function to call to parse args.  */
1075   void (* parms) PARAMS ((char *));
1076 };
1077
1078 static const struct asm_opcode insns[] =
1079 {
1080   /* Core ARM Instructions.  */
1081   {"and",        0xe0000000, 3,  ARM_EXT_V1,       do_arit},
1082   {"ands",       0xe0100000, 3,  ARM_EXT_V1,       do_arit},
1083   {"eor",        0xe0200000, 3,  ARM_EXT_V1,       do_arit},
1084   {"eors",       0xe0300000, 3,  ARM_EXT_V1,       do_arit},
1085   {"sub",        0xe0400000, 3,  ARM_EXT_V1,       do_arit},
1086   {"subs",       0xe0500000, 3,  ARM_EXT_V1,       do_arit},
1087   {"rsb",        0xe0600000, 3,  ARM_EXT_V1,       do_arit},
1088   {"rsbs",       0xe0700000, 3,  ARM_EXT_V1,       do_arit},
1089   {"add",        0xe0800000, 3,  ARM_EXT_V1,       do_arit},
1090   {"adds",       0xe0900000, 3,  ARM_EXT_V1,       do_arit},
1091   {"adc",        0xe0a00000, 3,  ARM_EXT_V1,       do_arit},
1092   {"adcs",       0xe0b00000, 3,  ARM_EXT_V1,       do_arit},
1093   {"sbc",        0xe0c00000, 3,  ARM_EXT_V1,       do_arit},
1094   {"sbcs",       0xe0d00000, 3,  ARM_EXT_V1,       do_arit},
1095   {"rsc",        0xe0e00000, 3,  ARM_EXT_V1,       do_arit},
1096   {"rscs",       0xe0f00000, 3,  ARM_EXT_V1,       do_arit},
1097   {"orr",        0xe1800000, 3,  ARM_EXT_V1,       do_arit},
1098   {"orrs",       0xe1900000, 3,  ARM_EXT_V1,       do_arit},
1099   {"bic",        0xe1c00000, 3,  ARM_EXT_V1,       do_arit},
1100   {"bics",       0xe1d00000, 3,  ARM_EXT_V1,       do_arit},
1101
1102   {"tst",        0xe1100000, 3,  ARM_EXT_V1,       do_cmp},
1103   {"tsts",       0xe1100000, 3,  ARM_EXT_V1,       do_cmp},
1104   {"tstp",       0xe110f000, 3,  ARM_EXT_V1,       do_cmp},
1105   {"teq",        0xe1300000, 3,  ARM_EXT_V1,       do_cmp},
1106   {"teqs",       0xe1300000, 3,  ARM_EXT_V1,       do_cmp},
1107   {"teqp",       0xe130f000, 3,  ARM_EXT_V1,       do_cmp},
1108   {"cmp",        0xe1500000, 3,  ARM_EXT_V1,       do_cmp},
1109   {"cmps",       0xe1500000, 3,  ARM_EXT_V1,       do_cmp},
1110   {"cmpp",       0xe150f000, 3,  ARM_EXT_V1,       do_cmp},
1111   {"cmn",        0xe1700000, 3,  ARM_EXT_V1,       do_cmp},
1112   {"cmns",       0xe1700000, 3,  ARM_EXT_V1,       do_cmp},
1113   {"cmnp",       0xe170f000, 3,  ARM_EXT_V1,       do_cmp},
1114
1115   {"mov",        0xe1a00000, 3,  ARM_EXT_V1,       do_mov},
1116   {"movs",       0xe1b00000, 3,  ARM_EXT_V1,       do_mov},
1117   {"mvn",        0xe1e00000, 3,  ARM_EXT_V1,       do_mov},
1118   {"mvns",       0xe1f00000, 3,  ARM_EXT_V1,       do_mov},
1119
1120   {"ldr",        0xe4100000, 3,  ARM_EXT_V1,       do_ldst},
1121   {"ldrb",       0xe4500000, 3,  ARM_EXT_V1,       do_ldst},
1122   {"ldrt",       0xe4300000, 3,  ARM_EXT_V1,       do_ldstt},
1123   {"ldrbt",      0xe4700000, 3,  ARM_EXT_V1,       do_ldstt},
1124   {"str",        0xe4000000, 3,  ARM_EXT_V1,       do_ldst},
1125   {"strb",       0xe4400000, 3,  ARM_EXT_V1,       do_ldst},
1126   {"strt",       0xe4200000, 3,  ARM_EXT_V1,       do_ldstt},
1127   {"strbt",      0xe4600000, 3,  ARM_EXT_V1,       do_ldstt},
1128
1129   {"stmia",      0xe8800000, 3,  ARM_EXT_V1,       do_ldmstm},
1130   {"stmib",      0xe9800000, 3,  ARM_EXT_V1,       do_ldmstm},
1131   {"stmda",      0xe8000000, 3,  ARM_EXT_V1,       do_ldmstm},
1132   {"stmdb",      0xe9000000, 3,  ARM_EXT_V1,       do_ldmstm},
1133   {"stmfd",      0xe9000000, 3,  ARM_EXT_V1,       do_ldmstm},
1134   {"stmfa",      0xe9800000, 3,  ARM_EXT_V1,       do_ldmstm},
1135   {"stmea",      0xe8800000, 3,  ARM_EXT_V1,       do_ldmstm},
1136   {"stmed",      0xe8000000, 3,  ARM_EXT_V1,       do_ldmstm},
1137
1138   {"ldmia",      0xe8900000, 3,  ARM_EXT_V1,       do_ldmstm},
1139   {"ldmib",      0xe9900000, 3,  ARM_EXT_V1,       do_ldmstm},
1140   {"ldmda",      0xe8100000, 3,  ARM_EXT_V1,       do_ldmstm},
1141   {"ldmdb",      0xe9100000, 3,  ARM_EXT_V1,       do_ldmstm},
1142   {"ldmfd",      0xe8900000, 3,  ARM_EXT_V1,       do_ldmstm},
1143   {"ldmfa",      0xe8100000, 3,  ARM_EXT_V1,       do_ldmstm},
1144   {"ldmea",      0xe9100000, 3,  ARM_EXT_V1,       do_ldmstm},
1145   {"ldmed",      0xe9900000, 3,  ARM_EXT_V1,       do_ldmstm},
1146
1147   {"swi",        0xef000000, 3,  ARM_EXT_V1,       do_swi},
1148 #ifdef TE_WINCE
1149   /* XXX This is the wrong place to do this.  Think multi-arch.  */
1150   {"bl",         0xeb000000, 2,  ARM_EXT_V1,       do_branch},
1151   {"b",          0xea000000, 1,  ARM_EXT_V1,       do_branch},
1152 #else
1153   {"bl",         0xebfffffe, 2,  ARM_EXT_V1,       do_branch},
1154   {"b",          0xeafffffe, 1,  ARM_EXT_V1,       do_branch},
1155 #endif
1156
1157   /* Pseudo ops.  */
1158   {"adr",        0xe28f0000, 3,  ARM_EXT_V1,       do_adr},
1159   {"adrl",       0xe28f0000, 3,  ARM_EXT_V1,       do_adrl},
1160   {"nop",        0xe1a00000, 3,  ARM_EXT_V1,       do_empty},
1161
1162   /* ARM 2 multiplies.  */
1163   {"mul",        0xe0000090, 3,  ARM_EXT_V2,       do_mul},
1164   {"muls",       0xe0100090, 3,  ARM_EXT_V2,       do_mul},
1165   {"mla",        0xe0200090, 3,  ARM_EXT_V2,       do_mla},
1166   {"mlas",       0xe0300090, 3,  ARM_EXT_V2,       do_mla},
1167
1168   /* Generic copressor instructions.  */
1169   {"cdp",        0xee000000, 3,  ARM_EXT_V2,       do_cdp},
1170   {"ldc",        0xec100000, 3,  ARM_EXT_V2,       do_lstc},
1171   {"ldcl",       0xec500000, 3,  ARM_EXT_V2,       do_lstc},
1172   {"stc",        0xec000000, 3,  ARM_EXT_V2,       do_lstc},
1173   {"stcl",       0xec400000, 3,  ARM_EXT_V2,       do_lstc},
1174   {"mcr",        0xee000010, 3,  ARM_EXT_V2,       do_co_reg},
1175   {"mrc",        0xee100010, 3,  ARM_EXT_V2,       do_co_reg},
1176
1177   /* ARM 3 - swp instructions.  */
1178   {"swp",        0xe1000090, 3,  ARM_EXT_V2S,      do_swap},
1179   {"swpb",       0xe1400090, 3,  ARM_EXT_V2S,      do_swap},
1180
1181   /* ARM 6 Status register instructions.  */
1182   {"mrs",        0xe10f0000, 3,  ARM_EXT_V3,       do_mrs},
1183   {"msr",        0xe120f000, 3,  ARM_EXT_V3,       do_msr},
1184   /* ScottB: our code uses     0xe128f000 for msr.
1185      NickC:  but this is wrong because the bits 16 through 19 are
1186              handled by the PSR_xxx defines above.  */
1187
1188   /* ARM 7M long multiplies.  */
1189   {"smull",      0xe0c00090, 5,  ARM_EXT_V3M,      do_mull},
1190   {"smulls",     0xe0d00090, 5,  ARM_EXT_V3M,      do_mull},
1191   {"umull",      0xe0800090, 5,  ARM_EXT_V3M,      do_mull},
1192   {"umulls",     0xe0900090, 5,  ARM_EXT_V3M,      do_mull},
1193   {"smlal",      0xe0e00090, 5,  ARM_EXT_V3M,      do_mull},
1194   {"smlals",     0xe0f00090, 5,  ARM_EXT_V3M,      do_mull},
1195   {"umlal",      0xe0a00090, 5,  ARM_EXT_V3M,      do_mull},
1196   {"umlals",     0xe0b00090, 5,  ARM_EXT_V3M,      do_mull},
1197
1198   /* ARM Architecture 4.  */
1199   {"ldrh",       0xe01000b0, 3,  ARM_EXT_V4,       do_ldstv4},
1200   {"ldrsh",      0xe01000f0, 3,  ARM_EXT_V4,       do_ldstv4},
1201   {"ldrsb",      0xe01000d0, 3,  ARM_EXT_V4,       do_ldstv4},
1202   {"strh",       0xe00000b0, 3,  ARM_EXT_V4,       do_ldstv4},
1203
1204   /* ARM Architecture 4T.  */
1205   /* Note: bx (and blx) are required on V5, even if the processor does
1206      not support Thumb.  */
1207   {"bx",         0xe12fff10, 2,  ARM_EXT_V4T | ARM_EXT_V5, do_bx},
1208
1209   /*  ARM Architecture 5T.  */
1210   /* Note: blx has 2 variants, so the .value is set dynamically.
1211      Only one of the variants has conditional execution.  */
1212   {"blx",        0xe0000000, 3,  ARM_EXT_V5,       do_blx},
1213   {"clz",        0xe16f0f10, 3,  ARM_EXT_V5,       do_clz},
1214   {"bkpt",       0xe1200070, 0,  ARM_EXT_V5,       do_bkpt},
1215   {"ldc2",       0xfc100000, 0,  ARM_EXT_V5,       do_lstc2},
1216   {"ldc2l",      0xfc500000, 0,  ARM_EXT_V5,       do_lstc2},
1217   {"stc2",       0xfc000000, 0,  ARM_EXT_V5,       do_lstc2},
1218   {"stc2l",      0xfc400000, 0,  ARM_EXT_V5,       do_lstc2},
1219   {"cdp2",       0xfe000000, 0,  ARM_EXT_V5,       do_cdp2},
1220   {"mcr2",       0xfe000010, 0,  ARM_EXT_V5,       do_co_reg2},
1221   {"mrc2",       0xfe100010, 0,  ARM_EXT_V5,       do_co_reg2},
1222
1223   /*  ARM Architecture 5TExP.  */
1224   {"smlabb",     0xe1000080, 6,  ARM_EXT_V5ExP,    do_smla},
1225   {"smlatb",     0xe10000a0, 6,  ARM_EXT_V5ExP,    do_smla},
1226   {"smlabt",     0xe10000c0, 6,  ARM_EXT_V5ExP,    do_smla},
1227   {"smlatt",     0xe10000e0, 6,  ARM_EXT_V5ExP,    do_smla},
1228
1229   {"smlawb",     0xe1200080, 6,  ARM_EXT_V5ExP,    do_smla},
1230   {"smlawt",     0xe12000c0, 6,  ARM_EXT_V5ExP,    do_smla},
1231
1232   {"smlalbb",    0xe1400080, 7,  ARM_EXT_V5ExP,    do_smlal},
1233   {"smlaltb",    0xe14000a0, 7,  ARM_EXT_V5ExP,    do_smlal},
1234   {"smlalbt",    0xe14000c0, 7,  ARM_EXT_V5ExP,    do_smlal},
1235   {"smlaltt",    0xe14000e0, 7,  ARM_EXT_V5ExP,    do_smlal},
1236
1237   {"smulbb",     0xe1600080, 6,  ARM_EXT_V5ExP,    do_smul},
1238   {"smultb",     0xe16000a0, 6,  ARM_EXT_V5ExP,    do_smul},
1239   {"smulbt",     0xe16000c0, 6,  ARM_EXT_V5ExP,    do_smul},
1240   {"smultt",     0xe16000e0, 6,  ARM_EXT_V5ExP,    do_smul},
1241
1242   {"smulwb",     0xe12000a0, 6,  ARM_EXT_V5ExP,    do_smul},
1243   {"smulwt",     0xe12000e0, 6,  ARM_EXT_V5ExP,    do_smul},
1244
1245   {"qadd",       0xe1000050, 4,  ARM_EXT_V5ExP,    do_qadd},
1246   {"qdadd",      0xe1400050, 5,  ARM_EXT_V5ExP,    do_qadd},
1247   {"qsub",       0xe1200050, 4,  ARM_EXT_V5ExP,    do_qadd},
1248   {"qdsub",      0xe1600050, 5,  ARM_EXT_V5ExP,    do_qadd},
1249
1250   /*  ARM Architecture 5TE.  */
1251   {"pld",        0xf450f000, 0,  ARM_EXT_V5E,      do_pld},
1252   {"ldrd",       0xe00000d0, 3,  ARM_EXT_V5E,      do_ldrd},
1253   {"strd",       0xe00000f0, 3,  ARM_EXT_V5E,      do_ldrd},
1254
1255   {"mcrr",       0xec400000, 4,  ARM_EXT_V5E,      do_co_reg2c},
1256   {"mrrc",       0xec500000, 4,  ARM_EXT_V5E,      do_co_reg2c},
1257
1258   /*  ARM Architecture 5TEJ.  */
1259   {"bxj",        0xe12fff20, 3,  ARM_EXT_V5J,      do_bxj},
1260
1261   /* Core FPA instruction set (V1).  */
1262   {"wfs",        0xee200110, 3,  FPU_FPA_EXT_V1,   do_fpa_ctrl},
1263   {"rfs",        0xee300110, 3,  FPU_FPA_EXT_V1,   do_fpa_ctrl},
1264   {"wfc",        0xee400110, 3,  FPU_FPA_EXT_V1,   do_fpa_ctrl},
1265   {"rfc",        0xee500110, 3,  FPU_FPA_EXT_V1,   do_fpa_ctrl},
1266
1267   {"ldfs",       0xec100100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1268   {"ldfd",       0xec108100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1269   {"ldfe",       0xec500100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1270   {"ldfp",       0xec508100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1271
1272   {"stfs",       0xec000100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1273   {"stfd",       0xec008100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1274   {"stfe",       0xec400100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1275   {"stfp",       0xec408100, 3,  FPU_FPA_EXT_V1,   do_fpa_ldst},
1276
1277   {"mvfs",       0xee008100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1278   {"mvfsp",      0xee008120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1279   {"mvfsm",      0xee008140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1280   {"mvfsz",      0xee008160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1281   {"mvfd",       0xee008180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1282   {"mvfdp",      0xee0081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1283   {"mvfdm",      0xee0081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1284   {"mvfdz",      0xee0081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1285   {"mvfe",       0xee088100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1286   {"mvfep",      0xee088120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1287   {"mvfem",      0xee088140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1288   {"mvfez",      0xee088160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1289
1290   {"mnfs",       0xee108100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1291   {"mnfsp",      0xee108120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1292   {"mnfsm",      0xee108140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1293   {"mnfsz",      0xee108160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1294   {"mnfd",       0xee108180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1295   {"mnfdp",      0xee1081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1296   {"mnfdm",      0xee1081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1297   {"mnfdz",      0xee1081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1298   {"mnfe",       0xee188100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1299   {"mnfep",      0xee188120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1300   {"mnfem",      0xee188140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1301   {"mnfez",      0xee188160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1302
1303   {"abss",       0xee208100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1304   {"abssp",      0xee208120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1305   {"abssm",      0xee208140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1306   {"abssz",      0xee208160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1307   {"absd",       0xee208180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1308   {"absdp",      0xee2081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1309   {"absdm",      0xee2081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1310   {"absdz",      0xee2081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1311   {"abse",       0xee288100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1312   {"absep",      0xee288120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1313   {"absem",      0xee288140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1314   {"absez",      0xee288160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1315
1316   {"rnds",       0xee308100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1317   {"rndsp",      0xee308120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1318   {"rndsm",      0xee308140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1319   {"rndsz",      0xee308160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1320   {"rndd",       0xee308180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1321   {"rnddp",      0xee3081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1322   {"rnddm",      0xee3081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1323   {"rnddz",      0xee3081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1324   {"rnde",       0xee388100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1325   {"rndep",      0xee388120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1326   {"rndem",      0xee388140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1327   {"rndez",      0xee388160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1328
1329   {"sqts",       0xee408100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1330   {"sqtsp",      0xee408120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1331   {"sqtsm",      0xee408140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1332   {"sqtsz",      0xee408160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1333   {"sqtd",       0xee408180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1334   {"sqtdp",      0xee4081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1335   {"sqtdm",      0xee4081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1336   {"sqtdz",      0xee4081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1337   {"sqte",       0xee488100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1338   {"sqtep",      0xee488120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1339   {"sqtem",      0xee488140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1340   {"sqtez",      0xee488160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1341
1342   {"logs",       0xee508100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1343   {"logsp",      0xee508120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1344   {"logsm",      0xee508140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1345   {"logsz",      0xee508160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1346   {"logd",       0xee508180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1347   {"logdp",      0xee5081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1348   {"logdm",      0xee5081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1349   {"logdz",      0xee5081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1350   {"loge",       0xee588100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1351   {"logep",      0xee588120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1352   {"logem",      0xee588140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1353   {"logez",      0xee588160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1354
1355   {"lgns",       0xee608100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1356   {"lgnsp",      0xee608120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1357   {"lgnsm",      0xee608140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1358   {"lgnsz",      0xee608160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1359   {"lgnd",       0xee608180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1360   {"lgndp",      0xee6081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1361   {"lgndm",      0xee6081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1362   {"lgndz",      0xee6081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1363   {"lgne",       0xee688100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1364   {"lgnep",      0xee688120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1365   {"lgnem",      0xee688140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1366   {"lgnez",      0xee688160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1367
1368   {"exps",       0xee708100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1369   {"expsp",      0xee708120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1370   {"expsm",      0xee708140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1371   {"expsz",      0xee708160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1372   {"expd",       0xee708180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1373   {"expdp",      0xee7081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1374   {"expdm",      0xee7081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1375   {"expdz",      0xee7081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1376   {"expe",       0xee788100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1377   {"expep",      0xee788120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1378   {"expem",      0xee788140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1379   {"expdz",      0xee788160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1380
1381   {"sins",       0xee808100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1382   {"sinsp",      0xee808120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1383   {"sinsm",      0xee808140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1384   {"sinsz",      0xee808160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1385   {"sind",       0xee808180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1386   {"sindp",      0xee8081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1387   {"sindm",      0xee8081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1388   {"sindz",      0xee8081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1389   {"sine",       0xee888100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1390   {"sinep",      0xee888120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1391   {"sinem",      0xee888140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1392   {"sinez",      0xee888160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1393
1394   {"coss",       0xee908100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1395   {"cossp",      0xee908120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1396   {"cossm",      0xee908140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1397   {"cossz",      0xee908160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1398   {"cosd",       0xee908180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1399   {"cosdp",      0xee9081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1400   {"cosdm",      0xee9081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1401   {"cosdz",      0xee9081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1402   {"cose",       0xee988100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1403   {"cosep",      0xee988120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1404   {"cosem",      0xee988140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1405   {"cosez",      0xee988160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1406
1407   {"tans",       0xeea08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1408   {"tansp",      0xeea08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1409   {"tansm",      0xeea08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1410   {"tansz",      0xeea08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1411   {"tand",       0xeea08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1412   {"tandp",      0xeea081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1413   {"tandm",      0xeea081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1414   {"tandz",      0xeea081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1415   {"tane",       0xeea88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1416   {"tanep",      0xeea88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1417   {"tanem",      0xeea88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1418   {"tanez",      0xeea88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1419
1420   {"asns",       0xeeb08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1421   {"asnsp",      0xeeb08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1422   {"asnsm",      0xeeb08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1423   {"asnsz",      0xeeb08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1424   {"asnd",       0xeeb08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1425   {"asndp",      0xeeb081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1426   {"asndm",      0xeeb081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1427   {"asndz",      0xeeb081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1428   {"asne",       0xeeb88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1429   {"asnep",      0xeeb88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1430   {"asnem",      0xeeb88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1431   {"asnez",      0xeeb88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1432
1433   {"acss",       0xeec08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1434   {"acssp",      0xeec08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1435   {"acssm",      0xeec08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1436   {"acssz",      0xeec08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1437   {"acsd",       0xeec08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1438   {"acsdp",      0xeec081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1439   {"acsdm",      0xeec081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1440   {"acsdz",      0xeec081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1441   {"acse",       0xeec88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1442   {"acsep",      0xeec88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1443   {"acsem",      0xeec88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1444   {"acsez",      0xeec88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1445
1446   {"atns",       0xeed08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1447   {"atnsp",      0xeed08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1448   {"atnsm",      0xeed08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1449   {"atnsz",      0xeed08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1450   {"atnd",       0xeed08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1451   {"atndp",      0xeed081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1452   {"atndm",      0xeed081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1453   {"atndz",      0xeed081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1454   {"atne",       0xeed88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1455   {"atnep",      0xeed88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1456   {"atnem",      0xeed88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1457   {"atnez",      0xeed88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1458
1459   {"urds",       0xeee08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1460   {"urdsp",      0xeee08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1461   {"urdsm",      0xeee08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1462   {"urdsz",      0xeee08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1463   {"urdd",       0xeee08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1464   {"urddp",      0xeee081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1465   {"urddm",      0xeee081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1466   {"urddz",      0xeee081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1467   {"urde",       0xeee88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1468   {"urdep",      0xeee88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1469   {"urdem",      0xeee88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1470   {"urdez",      0xeee88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1471
1472   {"nrms",       0xeef08100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1473   {"nrmsp",      0xeef08120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1474   {"nrmsm",      0xeef08140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1475   {"nrmsz",      0xeef08160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1476   {"nrmd",       0xeef08180, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1477   {"nrmdp",      0xeef081a0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1478   {"nrmdm",      0xeef081c0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1479   {"nrmdz",      0xeef081e0, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1480   {"nrme",       0xeef88100, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1481   {"nrmep",      0xeef88120, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1482   {"nrmem",      0xeef88140, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1483   {"nrmez",      0xeef88160, 3,  FPU_FPA_EXT_V1,   do_fpa_monadic},
1484
1485   {"adfs",       0xee000100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1486   {"adfsp",      0xee000120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1487   {"adfsm",      0xee000140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1488   {"adfsz",      0xee000160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1489   {"adfd",       0xee000180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1490   {"adfdp",      0xee0001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1491   {"adfdm",      0xee0001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1492   {"adfdz",      0xee0001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1493   {"adfe",       0xee080100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1494   {"adfep",      0xee080120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1495   {"adfem",      0xee080140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1496   {"adfez",      0xee080160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1497
1498   {"sufs",       0xee200100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1499   {"sufsp",      0xee200120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1500   {"sufsm",      0xee200140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1501   {"sufsz",      0xee200160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1502   {"sufd",       0xee200180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1503   {"sufdp",      0xee2001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1504   {"sufdm",      0xee2001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1505   {"sufdz",      0xee2001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1506   {"sufe",       0xee280100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1507   {"sufep",      0xee280120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1508   {"sufem",      0xee280140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1509   {"sufez",      0xee280160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1510
1511   {"rsfs",       0xee300100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1512   {"rsfsp",      0xee300120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1513   {"rsfsm",      0xee300140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1514   {"rsfsz",      0xee300160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1515   {"rsfd",       0xee300180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1516   {"rsfdp",      0xee3001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1517   {"rsfdm",      0xee3001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1518   {"rsfdz",      0xee3001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1519   {"rsfe",       0xee380100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1520   {"rsfep",      0xee380120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1521   {"rsfem",      0xee380140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1522   {"rsfez",      0xee380160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1523
1524   {"mufs",       0xee100100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1525   {"mufsp",      0xee100120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1526   {"mufsm",      0xee100140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1527   {"mufsz",      0xee100160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1528   {"mufd",       0xee100180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1529   {"mufdp",      0xee1001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1530   {"mufdm",      0xee1001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1531   {"mufdz",      0xee1001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1532   {"mufe",       0xee180100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1533   {"mufep",      0xee180120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1534   {"mufem",      0xee180140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1535   {"mufez",      0xee180160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1536
1537   {"dvfs",       0xee400100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1538   {"dvfsp",      0xee400120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1539   {"dvfsm",      0xee400140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1540   {"dvfsz",      0xee400160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1541   {"dvfd",       0xee400180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1542   {"dvfdp",      0xee4001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1543   {"dvfdm",      0xee4001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1544   {"dvfdz",      0xee4001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1545   {"dvfe",       0xee480100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1546   {"dvfep",      0xee480120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1547   {"dvfem",      0xee480140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1548   {"dvfez",      0xee480160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1549
1550   {"rdfs",       0xee500100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1551   {"rdfsp",      0xee500120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1552   {"rdfsm",      0xee500140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1553   {"rdfsz",      0xee500160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1554   {"rdfd",       0xee500180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1555   {"rdfdp",      0xee5001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1556   {"rdfdm",      0xee5001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1557   {"rdfdz",      0xee5001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1558   {"rdfe",       0xee580100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1559   {"rdfep",      0xee580120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1560   {"rdfem",      0xee580140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1561   {"rdfez",      0xee580160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1562
1563   {"pows",       0xee600100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1564   {"powsp",      0xee600120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1565   {"powsm",      0xee600140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1566   {"powsz",      0xee600160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1567   {"powd",       0xee600180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1568   {"powdp",      0xee6001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1569   {"powdm",      0xee6001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1570   {"powdz",      0xee6001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1571   {"powe",       0xee680100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1572   {"powep",      0xee680120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1573   {"powem",      0xee680140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1574   {"powez",      0xee680160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1575
1576   {"rpws",       0xee700100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1577   {"rpwsp",      0xee700120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1578   {"rpwsm",      0xee700140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1579   {"rpwsz",      0xee700160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1580   {"rpwd",       0xee700180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1581   {"rpwdp",      0xee7001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1582   {"rpwdm",      0xee7001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1583   {"rpwdz",      0xee7001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1584   {"rpwe",       0xee780100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1585   {"rpwep",      0xee780120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1586   {"rpwem",      0xee780140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1587   {"rpwez",      0xee780160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1588
1589   {"rmfs",       0xee800100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1590   {"rmfsp",      0xee800120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1591   {"rmfsm",      0xee800140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1592   {"rmfsz",      0xee800160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1593   {"rmfd",       0xee800180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1594   {"rmfdp",      0xee8001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1595   {"rmfdm",      0xee8001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1596   {"rmfdz",      0xee8001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1597   {"rmfe",       0xee880100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1598   {"rmfep",      0xee880120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1599   {"rmfem",      0xee880140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1600   {"rmfez",      0xee880160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1601
1602   {"fmls",       0xee900100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1603   {"fmlsp",      0xee900120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1604   {"fmlsm",      0xee900140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1605   {"fmlsz",      0xee900160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1606   {"fmld",       0xee900180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1607   {"fmldp",      0xee9001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1608   {"fmldm",      0xee9001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1609   {"fmldz",      0xee9001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1610   {"fmle",       0xee980100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1611   {"fmlep",      0xee980120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1612   {"fmlem",      0xee980140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1613   {"fmlez",      0xee980160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1614
1615   {"fdvs",       0xeea00100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1616   {"fdvsp",      0xeea00120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1617   {"fdvsm",      0xeea00140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1618   {"fdvsz",      0xeea00160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1619   {"fdvd",       0xeea00180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1620   {"fdvdp",      0xeea001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1621   {"fdvdm",      0xeea001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1622   {"fdvdz",      0xeea001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1623   {"fdve",       0xeea80100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1624   {"fdvep",      0xeea80120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1625   {"fdvem",      0xeea80140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1626   {"fdvez",      0xeea80160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1627
1628   {"frds",       0xeeb00100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1629   {"frdsp",      0xeeb00120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1630   {"frdsm",      0xeeb00140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1631   {"frdsz",      0xeeb00160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1632   {"frdd",       0xeeb00180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1633   {"frddp",      0xeeb001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1634   {"frddm",      0xeeb001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1635   {"frddz",      0xeeb001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1636   {"frde",       0xeeb80100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1637   {"frdep",      0xeeb80120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1638   {"frdem",      0xeeb80140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1639   {"frdez",      0xeeb80160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1640
1641   {"pols",       0xeec00100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1642   {"polsp",      0xeec00120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1643   {"polsm",      0xeec00140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1644   {"polsz",      0xeec00160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1645   {"pold",       0xeec00180, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1646   {"poldp",      0xeec001a0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1647   {"poldm",      0xeec001c0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1648   {"poldz",      0xeec001e0, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1649   {"pole",       0xeec80100, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1650   {"polep",      0xeec80120, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1651   {"polem",      0xeec80140, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1652   {"polez",      0xeec80160, 3,  FPU_FPA_EXT_V1,   do_fpa_dyadic},
1653
1654   {"cmf",        0xee90f110, 3,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1655   {"cmfe",       0xeed0f110, 3,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1656   {"cnf",        0xeeb0f110, 3,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1657   {"cnfe",       0xeef0f110, 3,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1658   /* The FPA10 data sheet suggests that the 'E' of cmfe/cnfe should
1659      not be an optional suffix, but part of the instruction.  To be
1660      compatible, we accept either.  */
1661   {"cmfe",       0xeed0f110, 4,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1662   {"cnfe",       0xeef0f110, 4,  FPU_FPA_EXT_V1,   do_fpa_cmp},
1663
1664   {"flts",       0xee000110, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1665   {"fltsp",      0xee000130, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1666   {"fltsm",      0xee000150, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1667   {"fltsz",      0xee000170, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1668   {"fltd",       0xee000190, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1669   {"fltdp",      0xee0001b0, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1670   {"fltdm",      0xee0001d0, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1671   {"fltdz",      0xee0001f0, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1672   {"flte",       0xee080110, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1673   {"fltep",      0xee080130, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1674   {"fltem",      0xee080150, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1675   {"fltez",      0xee080170, 3,  FPU_FPA_EXT_V1,   do_fpa_from_reg},
1676
1677   /* The implementation of the FIX instruction is broken on some
1678      assemblers, in that it accepts a precision specifier as well as a
1679      rounding specifier, despite the fact that this is meaningless.
1680      To be more compatible, we accept it as well, though of course it
1681      does not set any bits.  */
1682   {"fix",        0xee100110, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1683   {"fixp",       0xee100130, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1684   {"fixm",       0xee100150, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1685   {"fixz",       0xee100170, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1686   {"fixsp",      0xee100130, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1687   {"fixsm",      0xee100150, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1688   {"fixsz",      0xee100170, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1689   {"fixdp",      0xee100130, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1690   {"fixdm",      0xee100150, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1691   {"fixdz",      0xee100170, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1692   {"fixep",      0xee100130, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1693   {"fixem",      0xee100150, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1694   {"fixez",      0xee100170, 3,  FPU_FPA_EXT_V1,   do_fpa_to_reg},
1695
1696   /* Instructions that were new with the real FPA, call them V2.  */
1697   {"lfm",        0xec100200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1698   {"lfmfd",      0xec900200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1699   {"lfmea",      0xed100200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1700   {"sfm",        0xec000200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1701   {"sfmfd",      0xed000200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1702   {"sfmea",      0xec800200, 3,  FPU_FPA_EXT_V2,   do_fpa_ldmstm},
1703
1704   /* VFP V1xD (single precision).  */
1705   /* Moves and type conversions.  */
1706   {"fcpys",   0xeeb00a40, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1707   {"fmrs",    0xee100a10, 4, FPU_VFP_EXT_V1xD, do_vfp_reg_from_sp},
1708   {"fmsr",    0xee000a10, 4, FPU_VFP_EXT_V1xD, do_vfp_sp_from_reg},
1709   {"fmstat",  0xeef1fa10, 6, FPU_VFP_EXT_V1xD, do_empty},
1710   {"fsitos",  0xeeb80ac0, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1711   {"fuitos",  0xeeb80a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1712   {"ftosis",  0xeebd0a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1713   {"ftosizs", 0xeebd0ac0, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1714   {"ftouis",  0xeebc0a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1715   {"ftouizs", 0xeebc0ac0, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1716   {"fmrx",    0xeef00a10, 4, FPU_VFP_EXT_V1xD, do_vfp_reg_from_ctrl},
1717   {"fmxr",    0xeee00a10, 4, FPU_VFP_EXT_V1xD, do_vfp_ctrl_from_reg},
1718
1719   /* Memory operations.  */
1720   {"flds",    0xed100a00, 4, FPU_VFP_EXT_V1xD, do_vfp_sp_ldst},
1721   {"fsts",    0xed000a00, 4, FPU_VFP_EXT_V1xD, do_vfp_sp_ldst},
1722   {"fldmias", 0xec900a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmia},
1723   {"fldmfds", 0xec900a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmia},
1724   {"fldmdbs", 0xed300a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmdb},
1725   {"fldmeas", 0xed300a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmdb},
1726   {"fldmiax", 0xec900b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmia},
1727   {"fldmfdx", 0xec900b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmia},
1728   {"fldmdbx", 0xed300b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmdb},
1729   {"fldmeax", 0xed300b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmdb},
1730   {"fstmias", 0xec800a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmia},
1731   {"fstmeas", 0xec800a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmia},
1732   {"fstmdbs", 0xed200a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmdb},
1733   {"fstmfds", 0xed200a00, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_ldstmdb},
1734   {"fstmiax", 0xec800b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmia},
1735   {"fstmeax", 0xec800b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmia},
1736   {"fstmdbx", 0xed200b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmdb},
1737   {"fstmfdx", 0xed200b00, 7, FPU_VFP_EXT_V1xD, do_vfp_xp_ldstmdb},
1738
1739   /* Monadic operations.  */
1740   {"fabss",   0xeeb00ac0, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1741   {"fnegs",   0xeeb10a40, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1742   {"fsqrts",  0xeeb10ac0, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1743
1744   /* Dyadic operations.  */
1745   {"fadds",   0xee300a00, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1746   {"fsubs",   0xee300a40, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1747   {"fmuls",   0xee200a00, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1748   {"fdivs",   0xee800a00, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1749   {"fmacs",   0xee000a00, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1750   {"fmscs",   0xee100a00, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1751   {"fnmuls",  0xee200a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1752   {"fnmacs",  0xee000a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1753   {"fnmscs",  0xee100a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_dyadic},
1754
1755   /* Comparisons.  */
1756   {"fcmps",   0xeeb40a40, 5, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1757   {"fcmpzs",  0xeeb50a40, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_compare_z},
1758   {"fcmpes",  0xeeb40ac0, 6, FPU_VFP_EXT_V1xD, do_vfp_sp_monadic},
1759   {"fcmpezs", 0xeeb50ac0, 7, FPU_VFP_EXT_V1xD, do_vfp_sp_compare_z},
1760
1761   /* VFP V1 (Double precision).  */
1762   /* Moves and type conversions.  */
1763   {"fcpyd",   0xeeb00b40, 5, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1764   {"fcvtds",  0xeeb70ac0, 6, FPU_VFP_EXT_V1,   do_vfp_dp_sp_cvt},
1765   {"fcvtsd",  0xeeb70bc0, 6, FPU_VFP_EXT_V1,   do_vfp_sp_dp_cvt},
1766   {"fmdhr",   0xee200b10, 5, FPU_VFP_EXT_V1,   do_vfp_dp_from_reg},
1767   {"fmdlr",   0xee000b10, 5, FPU_VFP_EXT_V1,   do_vfp_dp_from_reg},
1768   {"fmrdh",   0xee300b10, 5, FPU_VFP_EXT_V1,   do_vfp_reg_from_dp},
1769   {"fmrdl",   0xee100b10, 5, FPU_VFP_EXT_V1,   do_vfp_reg_from_dp},
1770   {"fsitod",  0xeeb80bc0, 6, FPU_VFP_EXT_V1,   do_vfp_dp_sp_cvt},
1771   {"fuitod",  0xeeb80b40, 6, FPU_VFP_EXT_V1,   do_vfp_dp_sp_cvt},
1772   {"ftosid",  0xeebd0b40, 6, FPU_VFP_EXT_V1,   do_vfp_sp_dp_cvt},
1773   {"ftosizd", 0xeebd0bc0, 7, FPU_VFP_EXT_V1,   do_vfp_sp_dp_cvt},
1774   {"ftouid",  0xeebc0b40, 6, FPU_VFP_EXT_V1,   do_vfp_sp_dp_cvt},
1775   {"ftouizd", 0xeebc0bc0, 7, FPU_VFP_EXT_V1,   do_vfp_sp_dp_cvt},
1776
1777   /* Memory operations.  */
1778   {"fldd",    0xed100b00, 4, FPU_VFP_EXT_V1,   do_vfp_dp_ldst},
1779   {"fstd",    0xed000b00, 4, FPU_VFP_EXT_V1,   do_vfp_dp_ldst},
1780   {"fldmiad", 0xec900b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmia},
1781   {"fldmfdd", 0xec900b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmia},
1782   {"fldmdbd", 0xed300b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmdb},
1783   {"fldmead", 0xed300b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmdb},
1784   {"fstmiad", 0xec800b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmia},
1785   {"fstmead", 0xec800b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmia},
1786   {"fstmdbd", 0xed200b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmdb},
1787   {"fstmfdd", 0xed200b00, 7, FPU_VFP_EXT_V1,   do_vfp_dp_ldstmdb},
1788
1789   /* Monadic operations.  */
1790   {"fabsd",   0xeeb00bc0, 5, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1791   {"fnegd",   0xeeb10b40, 5, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1792   {"fsqrtd",  0xeeb10bc0, 6, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1793
1794   /* Dyadic operations.  */
1795   {"faddd",   0xee300b00, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1796   {"fsubd",   0xee300b40, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1797   {"fmuld",   0xee200b00, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1798   {"fdivd",   0xee800b00, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1799   {"fmacd",   0xee000b00, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1800   {"fmscd",   0xee100b00, 5, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1801   {"fnmuld",  0xee200b40, 6, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1802   {"fnmacd",  0xee000b40, 6, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1803   {"fnmscd",  0xee100b40, 6, FPU_VFP_EXT_V1,   do_vfp_dp_dyadic},
1804
1805   /* Comparisons.  */
1806   {"fcmpd",   0xeeb40b40, 5, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1807   {"fcmpzd",  0xeeb50b40, 6, FPU_VFP_EXT_V1,   do_vfp_dp_compare_z},
1808   {"fcmped",  0xeeb40bc0, 6, FPU_VFP_EXT_V1,   do_vfp_dp_monadic},
1809   {"fcmpezd", 0xeeb50bc0, 7, FPU_VFP_EXT_V1,   do_vfp_dp_compare_z},
1810
1811   /* VFP V2.  */
1812   {"fmsrr",   0xec400a10, 5, FPU_VFP_EXT_V2,   do_vfp_sp_reg2},
1813   {"fmrrs",   0xec500a10, 5, FPU_VFP_EXT_V2,   do_vfp_sp_reg2},
1814   {"fmdrr",   0xec400b10, 5, FPU_VFP_EXT_V2,   do_vfp_dp_from_reg2},
1815   {"fmrrd",   0xec500b10, 5, FPU_VFP_EXT_V2,   do_vfp_reg2_from_dp},
1816
1817   /* Intel XScale extensions to ARM V5 ISA.  (All use CP0).  */
1818   {"mia",        0xee200010, 3,  ARM_CEXT_XSCALE,   do_xsc_mia},
1819   {"miaph",      0xee280010, 5,  ARM_CEXT_XSCALE,   do_xsc_mia},
1820   {"miabb",      0xee2c0010, 5,  ARM_CEXT_XSCALE,   do_xsc_mia},
1821   {"miabt",      0xee2d0010, 5,  ARM_CEXT_XSCALE,   do_xsc_mia},
1822   {"miatb",      0xee2e0010, 5,  ARM_CEXT_XSCALE,   do_xsc_mia},
1823   {"miatt",      0xee2f0010, 5,  ARM_CEXT_XSCALE,   do_xsc_mia},
1824   {"mar",        0xec400000, 3,  ARM_CEXT_XSCALE,   do_xsc_mar},
1825   {"mra",        0xec500000, 3,  ARM_CEXT_XSCALE,   do_xsc_mra},
1826
1827   /* Intel Wireless MMX technology instructions.  */
1828   {"tandcb",     0xee130130, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tandc},
1829   {"tandch",     0xee530130, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tandc},
1830   {"tandcw",     0xee930130, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tandc},
1831   {"tbcstb",     0xee400010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tbcst},
1832   {"tbcsth",     0xee400050, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tbcst},
1833   {"tbcstw",     0xee400090, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tbcst},
1834   {"textrcb",    0xee130170, 7, ARM_CEXT_IWMMXT, do_iwmmxt_textrc},
1835   {"textrch",    0xee530170, 7, ARM_CEXT_IWMMXT, do_iwmmxt_textrc},
1836   {"textrcw",    0xee930170, 7, ARM_CEXT_IWMMXT, do_iwmmxt_textrc},
1837   {"textrmub",   0xee100070, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1838   {"textrmuh",   0xee500070, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1839   {"textrmuw",   0xee900070, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1840   {"textrmsb",   0xee100078, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1841   {"textrmsh",   0xee500078, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1842   {"textrmsw",   0xee900078, 8, ARM_CEXT_IWMMXT, do_iwmmxt_textrm},
1843   {"tinsrb",     0xee600010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tinsr},
1844   {"tinsrh",     0xee600050, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tinsr},
1845   {"tinsrw",     0xee600090, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tinsr},
1846   {"tmcr",       0xee000110, 4, ARM_CEXT_IWMMXT, do_iwmmxt_tmcr},
1847   {"tmcrr",      0xec400000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_tmcrr},
1848   {"tmia",       0xee200010, 4, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1849   {"tmiaph",     0xee280010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1850   {"tmiabb",     0xee2c0010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1851   {"tmiabt",     0xee2d0010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1852   {"tmiatb",     0xee2e0010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1853   {"tmiatt",     0xee2f0010, 6, ARM_CEXT_IWMMXT, do_iwmmxt_tmia},
1854   {"tmovmskb",   0xee100030, 8, ARM_CEXT_IWMMXT, do_iwmmxt_tmovmsk},
1855   {"tmovmskh",   0xee500030, 8, ARM_CEXT_IWMMXT, do_iwmmxt_tmovmsk},
1856   {"tmovmskw",   0xee900030, 8, ARM_CEXT_IWMMXT, do_iwmmxt_tmovmsk},
1857   {"tmrc",       0xee100110, 4, ARM_CEXT_IWMMXT, do_iwmmxt_tmrc},
1858   {"tmrrc",      0xec500000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_tmrrc},
1859   {"torcb",      0xee130150, 5, ARM_CEXT_IWMMXT, do_iwmmxt_torc},
1860   {"torch",      0xee530150, 5, ARM_CEXT_IWMMXT, do_iwmmxt_torc},
1861   {"torcw",      0xee930150, 5, ARM_CEXT_IWMMXT, do_iwmmxt_torc},
1862   {"waccb",      0xee0001c0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1863   {"wacch",      0xee4001c0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1864   {"waccw",      0xee8001c0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1865   {"waddbss",    0xee300180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1866   {"waddb",      0xee000180, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1867   {"waddbus",    0xee100180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1868   {"waddhss",    0xee700180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1869   {"waddh",      0xee400180, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1870   {"waddhus",    0xee500180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1871   {"waddwss",    0xeeb00180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1872   {"waddw",      0xee800180, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1873   {"waddwus",    0xee900180, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1874   {"waligni",    0xee000020, 7, ARM_CEXT_IWMMXT, do_iwmmxt_waligni},
1875   {"walignr0",   0xee800020, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1876   {"walignr1",   0xee900020, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1877   {"walignr2",   0xeea00020, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1878   {"walignr3",   0xeeb00020, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1879   {"wand",       0xee200000, 4, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1880   {"wandn",      0xee300000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1881   {"wavg2b",     0xee800000, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1882   {"wavg2br",    0xee900000, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1883   {"wavg2h",     0xeec00000, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1884   {"wavg2hr",    0xeed00000, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1885   {"wcmpeqb",    0xee000060, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1886   {"wcmpeqh",    0xee400060, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1887   {"wcmpeqw",    0xee800060, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1888   {"wcmpgtub",   0xee100060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1889   {"wcmpgtuh",   0xee500060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1890   {"wcmpgtuw",   0xee900060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1891   {"wcmpgtsb",   0xee300060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1892   {"wcmpgtsh",   0xee700060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1893   {"wcmpgtsw",   0xeeb00060, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1894   {"wldrb",      0xec100000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_byte_addr},
1895   {"wldrh",      0xec100100, 5, ARM_CEXT_IWMMXT, do_iwmmxt_byte_addr},
1896   {"wldrw",      0xec100200, 5, ARM_CEXT_IWMMXT, do_iwmmxt_word_addr},
1897   {"wldrd",      0xec100300, 5, ARM_CEXT_IWMMXT, do_iwmmxt_word_addr},
1898   {"wmacs",      0xee600100, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1899   {"wmacsz",     0xee700100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1900   {"wmacu",      0xee400100, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1901   {"wmacuz",     0xee500100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1902   {"wmadds",     0xeea00100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1903   {"wmaddu",     0xee800100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1904   {"wmaxsb",     0xee200160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1905   {"wmaxsh",     0xee600160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1906   {"wmaxsw",     0xeea00160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1907   {"wmaxub",     0xee000160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1908   {"wmaxuh",     0xee400160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1909   {"wmaxuw",     0xee800160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1910   {"wminsb",     0xee300160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1911   {"wminsh",     0xee700160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1912   {"wminsw",     0xeeb00160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1913   {"wminub",     0xee100160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1914   {"wminuh",     0xee500160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1915   {"wminuw",     0xee900160, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1916   {"wmov",       0xee000000, 4, ARM_CEXT_IWMMXT, do_iwmmxt_wmov},
1917   {"wmulsm",     0xee300100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1918   {"wmulsl",     0xee200100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1919   {"wmulum",     0xee100100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1920   {"wmulul",     0xee000100, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1921   {"wor",        0xee000000, 3, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1922   {"wpackhss",   0xee700080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1923   {"wpackhus",   0xee500080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1924   {"wpackwss",   0xeeb00080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1925   {"wpackwus",   0xee900080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1926   {"wpackdss",   0xeef00080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1927   {"wpackdus",   0xeed00080, 8, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1928   {"wrorh",      0xee700040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1929   {"wrorhg",     0xee700148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1930   {"wrorw",      0xeeb00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1931   {"wrorwg",     0xeeb00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1932   {"wrord",      0xeef00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1933   {"wrordg",     0xeef00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1934   {"wsadb",      0xee000120, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1935   {"wsadbz",     0xee100120, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1936   {"wsadh",      0xee400120, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1937   {"wsadhz",     0xee500120, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1938   {"wshufh",     0xee0001e0, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wshufh},
1939   {"wsllh",      0xee500040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1940   {"wsllhg",     0xee500148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1941   {"wsllw",      0xee900040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1942   {"wsllwg",     0xee900148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1943   {"wslld",      0xeed00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1944   {"wslldg",     0xeed00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1945   {"wsrah",      0xee400040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1946   {"wsrahg",     0xee400148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1947   {"wsraw",      0xee800040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1948   {"wsrawg",     0xee800148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1949   {"wsrad",      0xeec00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1950   {"wsradg",     0xeec00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1951   {"wsrlh",      0xee600040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1952   {"wsrlhg",     0xee600148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1953   {"wsrlw",      0xeea00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1954   {"wsrlwg",     0xeea00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1955   {"wsrld",      0xeee00040, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1956   {"wsrldg",     0xeee00148, 6, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwcg},
1957   {"wstrb",      0xec000000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_byte_addr},
1958   {"wstrh",      0xec000100, 5, ARM_CEXT_IWMMXT, do_iwmmxt_byte_addr},
1959   {"wstrw",      0xec000200, 5, ARM_CEXT_IWMMXT, do_iwmmxt_word_addr},
1960   {"wstrd",      0xec000300, 5, ARM_CEXT_IWMMXT, do_iwmmxt_word_addr},
1961   {"wsubbss",    0xee3001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1962   {"wsubb",      0xee0001a0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1963   {"wsubbus",    0xee1001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1964   {"wsubhss",    0xee7001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1965   {"wsubh",      0xee4001a0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1966   {"wsubhus",    0xee5001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1967   {"wsubwss",    0xeeb001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1968   {"wsubw",      0xee8001a0, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1969   {"wsubwus",    0xee9001a0, 7, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1970   {"wunpckehub", 0xee0000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1971   {"wunpckehuh", 0xee4000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1972   {"wunpckehuw", 0xee8000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1973   {"wunpckehsb", 0xee2000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1974   {"wunpckehsh", 0xee6000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1975   {"wunpckehsw", 0xeea000c0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1976   {"wunpckihb",  0xee1000c0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1977   {"wunpckihh",  0xee5000c0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1978   {"wunpckihw",  0xee9000c0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1979   {"wunpckelub", 0xee0000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1980   {"wunpckeluh", 0xee4000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1981   {"wunpckeluw", 0xee8000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1982   {"wunpckelsb", 0xee2000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1983   {"wunpckelsh", 0xee6000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1984   {"wunpckelsw", 0xeea000e0, 10, ARM_CEXT_IWMMXT, do_iwmmxt_wrwr},
1985   {"wunpckilb",  0xee1000e0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1986   {"wunpckilh",  0xee5000e0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1987   {"wunpckilw",  0xee9000e0, 9, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1988   {"wxor",       0xee100000, 4, ARM_CEXT_IWMMXT, do_iwmmxt_wrwrwr},
1989   {"wzero",      0xee300000, 5, ARM_CEXT_IWMMXT, do_iwmmxt_wzero},
1990
1991   /* Cirrus Maverick instructions.  */
1992   {"cfldrs",     0xec100400, 6,  ARM_CEXT_MAVERICK, do_mav_ldst_1},
1993   {"cfldrd",     0xec500400, 6,  ARM_CEXT_MAVERICK, do_mav_ldst_2},
1994   {"cfldr32",    0xec100500, 7,  ARM_CEXT_MAVERICK, do_mav_ldst_3},
1995   {"cfldr64",    0xec500500, 7,  ARM_CEXT_MAVERICK, do_mav_ldst_4},
1996   {"cfstrs",     0xec000400, 6,  ARM_CEXT_MAVERICK, do_mav_ldst_1},
1997   {"cfstrd",     0xec400400, 6,  ARM_CEXT_MAVERICK, do_mav_ldst_2},
1998   {"cfstr32",    0xec000500, 7,  ARM_CEXT_MAVERICK, do_mav_ldst_3},
1999   {"cfstr64",    0xec400500, 7,  ARM_CEXT_MAVERICK, do_mav_ldst_4},
2000   {"cfmvsr",     0xee000450, 6,  ARM_CEXT_MAVERICK, do_mav_binops_2a},
2001   {"cfmvrs",     0xee100450, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1a},
2002   {"cfmvdlr",    0xee000410, 7,  ARM_CEXT_MAVERICK, do_mav_binops_2b},
2003   {"cfmvrdl",    0xee100410, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1b},
2004   {"cfmvdhr",    0xee000430, 7,  ARM_CEXT_MAVERICK, do_mav_binops_2b},
2005   {"cfmvrdh",    0xee100430, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1b},
2006   {"cfmv64lr",   0xee000510, 8,  ARM_CEXT_MAVERICK, do_mav_binops_2c},
2007   {"cfmvr64l",   0xee100510, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1c},
2008   {"cfmv64hr",   0xee000530, 8,  ARM_CEXT_MAVERICK, do_mav_binops_2c},
2009   {"cfmvr64h",   0xee100530, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1c},
2010   {"cfmval32",   0xee100610, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3a},
2011   {"cfmv32al",   0xee000610, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3b},
2012   {"cfmvam32",   0xee100630, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3a},
2013   {"cfmv32am",   0xee000630, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3b},
2014   {"cfmvah32",   0xee100650, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3a},
2015   {"cfmv32ah",   0xee000650, 8,  ARM_CEXT_MAVERICK, do_mav_binops_3b},
2016   {"cfmva32",    0xee100670, 7,  ARM_CEXT_MAVERICK, do_mav_binops_3a},
2017   {"cfmv32a",    0xee000670, 7,  ARM_CEXT_MAVERICK, do_mav_binops_3b},
2018   {"cfmva64",    0xee100690, 7,  ARM_CEXT_MAVERICK, do_mav_binops_3c},
2019   {"cfmv64a",    0xee000690, 7,  ARM_CEXT_MAVERICK, do_mav_binops_3d},
2020   {"cfmvsc32",   0xee1006b0, 8,  ARM_CEXT_MAVERICK, do_mav_dspsc_1},
2021   {"cfmv32sc",   0xee0006b0, 8,  ARM_CEXT_MAVERICK, do_mav_dspsc_2},
2022   {"cfcpys",     0xee000400, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1d},
2023   {"cfcpyd",     0xee000420, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1e},
2024   {"cfcvtsd",    0xee000460, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1f},
2025   {"cfcvtds",    0xee000440, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1g},
2026   {"cfcvt32s",   0xee000480, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1h},
2027   {"cfcvt32d",   0xee0004a0, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1i},
2028   {"cfcvt64s",   0xee0004c0, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1j},
2029   {"cfcvt64d",   0xee0004e0, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1k},
2030   {"cfcvts32",   0xee100580, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1l},
2031   {"cfcvtd32",   0xee1005a0, 8,  ARM_CEXT_MAVERICK, do_mav_binops_1m},
2032   {"cftruncs32", 0xee1005c0, 10, ARM_CEXT_MAVERICK, do_mav_binops_1l},
2033   {"cftruncd32", 0xee1005e0, 10, ARM_CEXT_MAVERICK, do_mav_binops_1m},
2034   {"cfrshl32",   0xee000550, 8,  ARM_CEXT_MAVERICK, do_mav_triple_4a},
2035   {"cfrshl64",   0xee000570, 8,  ARM_CEXT_MAVERICK, do_mav_triple_4b},
2036   {"cfsh32",     0xee000500, 6,  ARM_CEXT_MAVERICK, do_mav_shift_1},
2037   {"cfsh64",     0xee200500, 6,  ARM_CEXT_MAVERICK, do_mav_shift_2},
2038   {"cfcmps",     0xee100490, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5a},
2039   {"cfcmpd",     0xee1004b0, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5b},
2040   {"cfcmp32",    0xee100590, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5c},
2041   {"cfcmp64",    0xee1005b0, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5d},
2042   {"cfabss",     0xee300400, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1d},
2043   {"cfabsd",     0xee300420, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1e},
2044   {"cfnegs",     0xee300440, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1d},
2045   {"cfnegd",     0xee300460, 6,  ARM_CEXT_MAVERICK, do_mav_binops_1e},
2046   {"cfadds",     0xee300480, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5e},
2047   {"cfaddd",     0xee3004a0, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5f},
2048   {"cfsubs",     0xee3004c0, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5e},
2049   {"cfsubd",     0xee3004e0, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5f},
2050   {"cfmuls",     0xee100400, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5e},
2051   {"cfmuld",     0xee100420, 6,  ARM_CEXT_MAVERICK, do_mav_triple_5f},
2052   {"cfabs32",    0xee300500, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1n},
2053   {"cfabs64",    0xee300520, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1o},
2054   {"cfneg32",    0xee300540, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1n},
2055   {"cfneg64",    0xee300560, 7,  ARM_CEXT_MAVERICK, do_mav_binops_1o},
2056   {"cfadd32",    0xee300580, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5g},
2057   {"cfadd64",    0xee3005a0, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5h},
2058   {"cfsub32",    0xee3005c0, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5g},
2059   {"cfsub64",    0xee3005e0, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5h},
2060   {"cfmul32",    0xee100500, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5g},
2061   {"cfmul64",    0xee100520, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5h},
2062   {"cfmac32",    0xee100540, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5g},
2063   {"cfmsc32",    0xee100560, 7,  ARM_CEXT_MAVERICK, do_mav_triple_5g},
2064   {"cfmadd32",   0xee000600, 8,  ARM_CEXT_MAVERICK, do_mav_quad_6a},
2065   {"cfmsub32",   0xee100600, 8,  ARM_CEXT_MAVERICK, do_mav_quad_6a},
2066   {"cfmadda32",  0xee200600, 9,  ARM_CEXT_MAVERICK, do_mav_quad_6b},
2067   {"cfmsuba32",  0xee300600, 9,  ARM_CEXT_MAVERICK, do_mav_quad_6b},
2068 };
2069
2070 /* Defines for various bits that we will want to toggle.  */
2071 #define INST_IMMEDIATE  0x02000000
2072 #define OFFSET_REG      0x02000000
2073 #define HWOFFSET_IMM    0x00400000
2074 #define SHIFT_BY_REG    0x00000010
2075 #define PRE_INDEX       0x01000000
2076 #define INDEX_UP        0x00800000
2077 #define WRITE_BACK      0x00200000
2078 #define LDM_TYPE_2_OR_3 0x00400000
2079
2080 #define LITERAL_MASK    0xf000f000
2081 #define OPCODE_MASK     0xfe1fffff
2082 #define V4_STR_BIT      0x00000020
2083
2084 #define DATA_OP_SHIFT   21
2085
2086 /* Codes to distinguish the arithmetic instructions.  */
2087 #define OPCODE_AND      0
2088 #define OPCODE_EOR      1
2089 #define OPCODE_SUB      2
2090 #define OPCODE_RSB      3
2091 #define OPCODE_ADD      4
2092 #define OPCODE_ADC      5
2093 #define OPCODE_SBC      6
2094 #define OPCODE_RSC      7
2095 #define OPCODE_TST      8
2096 #define OPCODE_TEQ      9
2097 #define OPCODE_CMP      10
2098 #define OPCODE_CMN      11
2099 #define OPCODE_ORR      12
2100 #define OPCODE_MOV      13
2101 #define OPCODE_BIC      14
2102 #define OPCODE_MVN      15
2103
2104 /* Thumb v1 (ARMv4T).  */
2105 static void do_t_nop            PARAMS ((char *));
2106 static void do_t_arit           PARAMS ((char *));
2107 static void do_t_add            PARAMS ((char *));
2108 static void do_t_asr            PARAMS ((char *));
2109 static void do_t_branch9        PARAMS ((char *));
2110 static void do_t_branch12       PARAMS ((char *));
2111 static void do_t_branch23       PARAMS ((char *));
2112 static void do_t_bx             PARAMS ((char *));
2113 static void do_t_compare        PARAMS ((char *));
2114 static void do_t_ldmstm         PARAMS ((char *));
2115 static void do_t_ldr            PARAMS ((char *));
2116 static void do_t_ldrb           PARAMS ((char *));
2117 static void do_t_ldrh           PARAMS ((char *));
2118 static void do_t_lds            PARAMS ((char *));
2119 static void do_t_lsl            PARAMS ((char *));
2120 static void do_t_lsr            PARAMS ((char *));
2121 static void do_t_mov            PARAMS ((char *));
2122 static void do_t_push_pop       PARAMS ((char *));
2123 static void do_t_str            PARAMS ((char *));
2124 static void do_t_strb           PARAMS ((char *));
2125 static void do_t_strh           PARAMS ((char *));
2126 static void do_t_sub            PARAMS ((char *));
2127 static void do_t_swi            PARAMS ((char *));
2128 static void do_t_adr            PARAMS ((char *));
2129
2130 /* Thumb v2 (ARMv5T).  */
2131 static void do_t_blx            PARAMS ((char *));
2132 static void do_t_bkpt           PARAMS ((char *));
2133
2134 #define T_OPCODE_MUL 0x4340
2135 #define T_OPCODE_TST 0x4200
2136 #define T_OPCODE_CMN 0x42c0
2137 #define T_OPCODE_NEG 0x4240
2138 #define T_OPCODE_MVN 0x43c0
2139
2140 #define T_OPCODE_ADD_R3 0x1800
2141 #define T_OPCODE_SUB_R3 0x1a00
2142 #define T_OPCODE_ADD_HI 0x4400
2143 #define T_OPCODE_ADD_ST 0xb000
2144 #define T_OPCODE_SUB_ST 0xb080
2145 #define T_OPCODE_ADD_SP 0xa800
2146 #define T_OPCODE_ADD_PC 0xa000
2147 #define T_OPCODE_ADD_I8 0x3000
2148 #define T_OPCODE_SUB_I8 0x3800
2149 #define T_OPCODE_ADD_I3 0x1c00
2150 #define T_OPCODE_SUB_I3 0x1e00
2151
2152 #define T_OPCODE_ASR_R  0x4100
2153 #define T_OPCODE_LSL_R  0x4080
2154 #define T_OPCODE_LSR_R  0x40c0
2155 #define T_OPCODE_ASR_I  0x1000
2156 #define T_OPCODE_LSL_I  0x0000
2157 #define T_OPCODE_LSR_I  0x0800
2158
2159 #define T_OPCODE_MOV_I8 0x2000
2160 #define T_OPCODE_CMP_I8 0x2800
2161 #define T_OPCODE_CMP_LR 0x4280
2162 #define T_OPCODE_MOV_HR 0x4600
2163 #define T_OPCODE_CMP_HR 0x4500
2164
2165 #define T_OPCODE_LDR_PC 0x4800
2166 #define T_OPCODE_LDR_SP 0x9800
2167 #define T_OPCODE_STR_SP 0x9000
2168 #define T_OPCODE_LDR_IW 0x6800
2169 #define T_OPCODE_STR_IW 0x6000
2170 #define T_OPCODE_LDR_IH 0x8800
2171 #define T_OPCODE_STR_IH 0x8000
2172 #define T_OPCODE_LDR_IB 0x7800
2173 #define T_OPCODE_STR_IB 0x7000
2174 #define T_OPCODE_LDR_RW 0x5800
2175 #define T_OPCODE_STR_RW 0x5000
2176 #define T_OPCODE_LDR_RH 0x5a00
2177 #define T_OPCODE_STR_RH 0x5200
2178 #define T_OPCODE_LDR_RB 0x5c00
2179 #define T_OPCODE_STR_RB 0x5400
2180
2181 #define T_OPCODE_PUSH   0xb400
2182 #define T_OPCODE_POP    0xbc00
2183
2184 #define T_OPCODE_BRANCH 0xe7fe
2185
2186 static int thumb_reg            PARAMS ((char ** str, int hi_lo));
2187
2188 #define THUMB_SIZE      2       /* Size of thumb instruction.  */
2189 #define THUMB_REG_LO    0x1
2190 #define THUMB_REG_HI    0x2
2191 #define THUMB_REG_ANY   0x3
2192
2193 #define THUMB_H1        0x0080
2194 #define THUMB_H2        0x0040
2195
2196 #define THUMB_ASR 0
2197 #define THUMB_LSL 1
2198 #define THUMB_LSR 2
2199
2200 #define THUMB_MOVE 0
2201 #define THUMB_COMPARE 1
2202
2203 #define THUMB_LOAD 0
2204 #define THUMB_STORE 1
2205
2206 #define THUMB_PP_PC_LR 0x0100
2207
2208 /* These three are used for immediate shifts, do not alter.  */
2209 #define THUMB_WORD 2
2210 #define THUMB_HALFWORD 1
2211 #define THUMB_BYTE 0
2212
2213 struct thumb_opcode
2214 {
2215   /* Basic string to match.  */
2216   const char * template;
2217
2218   /* Basic instruction code.  */
2219   unsigned long value;
2220
2221   int size;
2222
2223   /* Which CPU variants this exists for.  */
2224   unsigned long variant;
2225
2226   /* Function to call to parse args.  */
2227   void (* parms) PARAMS ((char *));
2228 };
2229
2230 static const struct thumb_opcode tinsns[] =
2231 {
2232   /* Thumb v1 (ARMv4T).  */
2233   {"adc",       0x4140,         2,      ARM_EXT_V4T, do_t_arit},
2234   {"add",       0x0000,         2,      ARM_EXT_V4T, do_t_add},
2235   {"and",       0x4000,         2,      ARM_EXT_V4T, do_t_arit},
2236   {"asr",       0x0000,         2,      ARM_EXT_V4T, do_t_asr},
2237   {"b",         T_OPCODE_BRANCH, 2,     ARM_EXT_V4T, do_t_branch12},
2238   {"beq",       0xd0fe,         2,      ARM_EXT_V4T, do_t_branch9},
2239   {"bne",       0xd1fe,         2,      ARM_EXT_V4T, do_t_branch9},
2240   {"bcs",       0xd2fe,         2,      ARM_EXT_V4T, do_t_branch9},
2241   {"bhs",       0xd2fe,         2,      ARM_EXT_V4T, do_t_branch9},
2242   {"bcc",       0xd3fe,         2,      ARM_EXT_V4T, do_t_branch9},
2243   {"bul",       0xd3fe,         2,      ARM_EXT_V4T, do_t_branch9},
2244   {"blo",       0xd3fe,         2,      ARM_EXT_V4T, do_t_branch9},
2245   {"bmi",       0xd4fe,         2,      ARM_EXT_V4T, do_t_branch9},
2246   {"bpl",       0xd5fe,         2,      ARM_EXT_V4T, do_t_branch9},
2247   {"bvs",       0xd6fe,         2,      ARM_EXT_V4T, do_t_branch9},
2248   {"bvc",       0xd7fe,         2,      ARM_EXT_V4T, do_t_branch9},
2249   {"bhi",       0xd8fe,         2,      ARM_EXT_V4T, do_t_branch9},
2250   {"bls",       0xd9fe,         2,      ARM_EXT_V4T, do_t_branch9},
2251   {"bge",       0xdafe,         2,      ARM_EXT_V4T, do_t_branch9},
2252   {"blt",       0xdbfe,         2,      ARM_EXT_V4T, do_t_branch9},
2253   {"bgt",       0xdcfe,         2,      ARM_EXT_V4T, do_t_branch9},
2254   {"ble",       0xddfe,         2,      ARM_EXT_V4T, do_t_branch9},
2255   {"bal",       0xdefe,         2,      ARM_EXT_V4T, do_t_branch9},
2256   {"bic",       0x4380,         2,      ARM_EXT_V4T, do_t_arit},
2257   {"bl",        0xf7fffffe,     4,      ARM_EXT_V4T, do_t_branch23},
2258   {"bx",        0x4700,         2,      ARM_EXT_V4T, do_t_bx},
2259   {"cmn",       T_OPCODE_CMN,   2,      ARM_EXT_V4T, do_t_arit},
2260   {"cmp",       0x0000,         2,      ARM_EXT_V4T, do_t_compare},
2261   {"eor",       0x4040,         2,      ARM_EXT_V4T, do_t_arit},
2262   {"ldmia",     0xc800,         2,      ARM_EXT_V4T, do_t_ldmstm},
2263   {"ldr",       0x0000,         2,      ARM_EXT_V4T, do_t_ldr},
2264   {"ldrb",      0x0000,         2,      ARM_EXT_V4T, do_t_ldrb},
2265   {"ldrh",      0x0000,         2,      ARM_EXT_V4T, do_t_ldrh},
2266   {"ldrsb",     0x5600,         2,      ARM_EXT_V4T, do_t_lds},
2267   {"ldrsh",     0x5e00,         2,      ARM_EXT_V4T, do_t_lds},
2268   {"ldsb",      0x5600,         2,      ARM_EXT_V4T, do_t_lds},
2269   {"ldsh",      0x5e00,         2,      ARM_EXT_V4T, do_t_lds},
2270   {"lsl",       0x0000,         2,      ARM_EXT_V4T, do_t_lsl},
2271   {"lsr",       0x0000,         2,      ARM_EXT_V4T, do_t_lsr},
2272   {"mov",       0x0000,         2,      ARM_EXT_V4T, do_t_mov},
2273   {"mul",       T_OPCODE_MUL,   2,      ARM_EXT_V4T, do_t_arit},
2274   {"mvn",       T_OPCODE_MVN,   2,      ARM_EXT_V4T, do_t_arit},
2275   {"neg",       T_OPCODE_NEG,   2,      ARM_EXT_V4T, do_t_arit},
2276   {"orr",       0x4300,         2,      ARM_EXT_V4T, do_t_arit},
2277   {"pop",       0xbc00,         2,      ARM_EXT_V4T, do_t_push_pop},
2278   {"push",      0xb400,         2,      ARM_EXT_V4T, do_t_push_pop},
2279   {"ror",       0x41c0,         2,      ARM_EXT_V4T, do_t_arit},
2280   {"sbc",       0x4180,         2,      ARM_EXT_V4T, do_t_arit},
2281   {"stmia",     0xc000,         2,      ARM_EXT_V4T, do_t_ldmstm},
2282   {"str",       0x0000,         2,      ARM_EXT_V4T, do_t_str},
2283   {"strb",      0x0000,         2,      ARM_EXT_V4T, do_t_strb},
2284   {"strh",      0x0000,         2,      ARM_EXT_V4T, do_t_strh},
2285   {"swi",       0xdf00,         2,      ARM_EXT_V4T, do_t_swi},
2286   {"sub",       0x0000,         2,      ARM_EXT_V4T, do_t_sub},
2287   {"tst",       T_OPCODE_TST,   2,      ARM_EXT_V4T, do_t_arit},
2288   /* Pseudo ops:  */
2289   {"adr",       0x0000,         2,      ARM_EXT_V4T, do_t_adr},
2290   {"nop",       0x46C0,         2,      ARM_EXT_V4T, do_t_nop},      /* mov r8,r8  */
2291   /* Thumb v2 (ARMv5T).  */
2292   {"blx",       0,              0,      ARM_EXT_V5T, do_t_blx},
2293   {"bkpt",      0xbe00,         2,      ARM_EXT_V5T, do_t_bkpt},
2294 };
2295
2296 #define BAD_ARGS        _("bad arguments to instruction")
2297 #define BAD_PC          _("r15 not allowed here")
2298 #define BAD_COND        _("instruction is not conditional")
2299 #define ERR_NO_ACCUM    _("acc0 expected")
2300
2301 static struct hash_control * arm_ops_hsh   = NULL;
2302 static struct hash_control * arm_tops_hsh  = NULL;
2303 static struct hash_control * arm_cond_hsh  = NULL;
2304 static struct hash_control * arm_shift_hsh = NULL;
2305 static struct hash_control * arm_psr_hsh   = NULL;
2306
2307 /* This table describes all the machine specific pseudo-ops the assembler
2308    has to support.  The fields are:
2309      pseudo-op name without dot
2310      function to call to execute this pseudo-op
2311      Integer arg to pass to the function.  */
2312
2313 static void s_req PARAMS ((int));
2314 static void s_align PARAMS ((int));
2315 static void s_bss PARAMS ((int));
2316 static void s_even PARAMS ((int));
2317 static void s_ltorg PARAMS ((int));
2318 static void s_arm PARAMS ((int));
2319 static void s_thumb PARAMS ((int));
2320 static void s_code PARAMS ((int));
2321 static void s_force_thumb PARAMS ((int));
2322 static void s_thumb_func PARAMS ((int));
2323 static void s_thumb_set PARAMS ((int));
2324 #ifdef OBJ_ELF
2325 static void s_arm_elf_cons PARAMS ((int));
2326 #endif
2327
2328 static int my_get_expression PARAMS ((expressionS *, char **));
2329
2330 const pseudo_typeS md_pseudo_table[] =
2331 {
2332   /* Never called becasue '.req' does not start line.  */
2333   { "req",         s_req,         0 },
2334   { "bss",         s_bss,         0 },
2335   { "align",       s_align,       0 },
2336   { "arm",         s_arm,         0 },
2337   { "thumb",       s_thumb,       0 },
2338   { "code",        s_code,        0 },
2339   { "force_thumb", s_force_thumb, 0 },
2340   { "thumb_func",  s_thumb_func,  0 },
2341   { "thumb_set",   s_thumb_set,   0 },
2342   { "even",        s_even,        0 },
2343   { "ltorg",       s_ltorg,       0 },
2344   { "pool",        s_ltorg,       0 },
2345 #ifdef OBJ_ELF
2346   { "word",        s_arm_elf_cons, 4 },
2347   { "long",        s_arm_elf_cons, 4 },
2348 #else
2349   { "word",        cons, 4},
2350 #endif
2351   { "extend",      float_cons, 'x' },
2352   { "ldouble",     float_cons, 'x' },
2353   { "packed",      float_cons, 'p' },
2354   { 0, 0, 0 }
2355 };
2356
2357 /* Other internal functions.  */
2358 static int arm_parse_extension PARAMS ((char *, int *));
2359 static int arm_parse_cpu PARAMS ((char *));
2360 static int arm_parse_arch PARAMS ((char *));
2361 static int arm_parse_fpu PARAMS ((char *));
2362 #if defined OBJ_COFF || defined OBJ_ELF
2363 static void arm_add_note PARAMS ((const char *, const char *, unsigned int));
2364 #endif
2365
2366 /* Stuff needed to resolve the label ambiguity
2367    As:
2368      ...
2369      label:   <insn>
2370    may differ from:
2371      ...
2372      label:
2373               <insn>
2374 */
2375
2376 symbolS *  last_label_seen;
2377 static int label_is_thumb_function_name = FALSE;
2378
2379 /* Literal Pool stuff.  */
2380
2381 #define MAX_LITERAL_POOL_SIZE 1024
2382
2383 /* Literal pool structure.  Held on a per-section
2384    and per-sub-section basis.  */
2385 typedef struct literal_pool
2386 {
2387   expressionS    literals [MAX_LITERAL_POOL_SIZE];
2388   unsigned int   next_free_entry;
2389   unsigned int   id;
2390   symbolS *      symbol;
2391   segT           section;
2392   subsegT        sub_section;
2393   struct literal_pool * next;
2394 } literal_pool;
2395
2396 /* Pointer to a linked list of literal pools.  */
2397 literal_pool * list_of_pools = NULL;
2398
2399 static literal_pool * find_literal_pool PARAMS ((void));
2400 static literal_pool * find_or_make_literal_pool PARAMS ((void));
2401
2402 static literal_pool *
2403 find_literal_pool ()
2404 {
2405   literal_pool * pool;
2406
2407   for (pool = list_of_pools; pool != NULL; pool = pool->next)
2408     {
2409       if (pool->section == now_seg
2410           && pool->sub_section == now_subseg)
2411         break;
2412     }
2413
2414   return pool;
2415 }
2416
2417 static literal_pool *
2418 find_or_make_literal_pool ()
2419 {
2420   /* Next literal pool ID number.  */
2421   static unsigned int latest_pool_num = 1;
2422   literal_pool *      pool;
2423
2424   pool = find_literal_pool ();
2425
2426   if (pool == NULL)
2427     {
2428       /* Create a new pool.  */
2429       pool = (literal_pool *) xmalloc (sizeof (* pool));
2430       if (! pool)
2431         return NULL;
2432
2433       pool->next_free_entry = 0;
2434       pool->section         = now_seg;
2435       pool->sub_section     = now_subseg;
2436       pool->next            = list_of_pools;
2437       pool->symbol          = NULL;
2438
2439       /* Add it to the list.  */
2440       list_of_pools = pool;
2441     }
2442
2443   /* New pools, and emptied pools, will have a NULL symbol.  */
2444   if (pool->symbol == NULL)
2445     {
2446       pool->symbol = symbol_create (FAKE_LABEL_NAME, undefined_section,
2447                                     (valueT) 0, &zero_address_frag);
2448       pool->id = latest_pool_num ++;
2449     }
2450
2451   /* Done.  */
2452   return pool;
2453 }
2454
2455 /* Add the literal in the global 'inst'
2456    structure to the relevent literal pool.  */
2457 static int
2458 add_to_lit_pool ()
2459 {
2460   literal_pool * pool;
2461   unsigned int entry;
2462
2463   pool = find_or_make_literal_pool ();
2464
2465   /* Check if this literal value is already in the pool.  */
2466   for (entry = 0; entry < pool->next_free_entry; entry ++)
2467     {
2468       if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
2469           && (inst.reloc.exp.X_op == O_constant)
2470           && (pool->literals[entry].X_add_number
2471               == inst.reloc.exp.X_add_number)
2472           && (pool->literals[entry].X_unsigned
2473               == inst.reloc.exp.X_unsigned))
2474         break;
2475
2476       if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
2477           && (inst.reloc.exp.X_op == O_symbol)
2478           && (pool->literals[entry].X_add_number
2479               == inst.reloc.exp.X_add_number)
2480           && (pool->literals[entry].X_add_symbol
2481               == inst.reloc.exp.X_add_symbol)
2482           && (pool->literals[entry].X_op_symbol
2483               == inst.reloc.exp.X_op_symbol))
2484         break;
2485     }
2486
2487   /* Do we need to create a new entry?  */
2488   if (entry == pool->next_free_entry)
2489     {
2490       if (entry >= MAX_LITERAL_POOL_SIZE)
2491         {
2492           inst.error = _("literal pool overflow");
2493           return FAIL;
2494         }
2495
2496       pool->literals[entry] = inst.reloc.exp;
2497       pool->next_free_entry += 1;
2498     }
2499
2500   inst.reloc.exp.X_op         = O_symbol;
2501   inst.reloc.exp.X_add_number = ((int) entry) * 4 - 8;
2502   inst.reloc.exp.X_add_symbol = pool->symbol;
2503
2504   return SUCCESS;
2505 }
2506
2507 /* Can't use symbol_new here, so have to create a symbol and then at
2508    a later date assign it a value. Thats what these functions do.  */
2509
2510 static void
2511 symbol_locate (symbolP, name, segment, valu, frag)
2512      symbolS *    symbolP;
2513      const char * name;         /* It is copied, the caller can modify.  */
2514      segT         segment;      /* Segment identifier (SEG_<something>).  */
2515      valueT       valu;         /* Symbol value.  */
2516      fragS *      frag;         /* Associated fragment.  */
2517 {
2518   unsigned int name_length;
2519   char * preserved_copy_of_name;
2520
2521   name_length = strlen (name) + 1;   /* +1 for \0.  */
2522   obstack_grow (&notes, name, name_length);
2523   preserved_copy_of_name = obstack_finish (&notes);
2524 #ifdef STRIP_UNDERSCORE
2525   if (preserved_copy_of_name[0] == '_')
2526     preserved_copy_of_name++;
2527 #endif
2528
2529 #ifdef tc_canonicalize_symbol_name
2530   preserved_copy_of_name =
2531     tc_canonicalize_symbol_name (preserved_copy_of_name);
2532 #endif
2533
2534   S_SET_NAME (symbolP, preserved_copy_of_name);
2535
2536   S_SET_SEGMENT (symbolP, segment);
2537   S_SET_VALUE (symbolP, valu);
2538   symbol_clear_list_pointers (symbolP);
2539
2540   symbol_set_frag (symbolP, frag);
2541
2542   /* Link to end of symbol chain.  */
2543   {
2544     extern int symbol_table_frozen;
2545     if (symbol_table_frozen)
2546       abort ();
2547   }
2548
2549   symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
2550
2551   obj_symbol_new_hook (symbolP);
2552
2553 #ifdef tc_symbol_new_hook
2554   tc_symbol_new_hook (symbolP);
2555 #endif
2556
2557 #ifdef DEBUG_SYMS
2558   verify_symbol_chain (symbol_rootP, symbol_lastP);
2559 #endif /* DEBUG_SYMS  */
2560 }
2561
2562 /* Check that an immediate is valid.
2563    If so, convert it to the right format.  */
2564
2565 static unsigned int
2566 validate_immediate (val)
2567      unsigned int val;
2568 {
2569   unsigned int a;
2570   unsigned int i;
2571
2572 #define rotate_left(v, n) (v << n | v >> (32 - n))
2573
2574   for (i = 0; i < 32; i += 2)
2575     if ((a = rotate_left (val, i)) <= 0xff)
2576       return a | (i << 7); /* 12-bit pack: [shift-cnt,const].  */
2577
2578   return FAIL;
2579 }
2580
2581 /* Check to see if an immediate can be computed as two seperate immediate
2582    values, added together.  We already know that this value cannot be
2583    computed by just one ARM instruction.  */
2584
2585 static unsigned int
2586 validate_immediate_twopart (val, highpart)
2587      unsigned int   val;
2588      unsigned int * highpart;
2589 {
2590   unsigned int a;
2591   unsigned int i;
2592
2593   for (i = 0; i < 32; i += 2)
2594     if (((a = rotate_left (val, i)) & 0xff) != 0)
2595       {
2596         if (a & 0xff00)
2597           {
2598             if (a & ~ 0xffff)
2599               continue;
2600             * highpart = (a  >> 8) | ((i + 24) << 7);
2601           }
2602         else if (a & 0xff0000)
2603           {
2604             if (a & 0xff000000)
2605               continue;
2606             * highpart = (a >> 16) | ((i + 16) << 7);
2607           }
2608         else
2609           {
2610             assert (a & 0xff000000);
2611             * highpart = (a >> 24) | ((i + 8) << 7);
2612           }
2613
2614         return (a & 0xff) | (i << 7);
2615       }
2616
2617   return FAIL;
2618 }
2619
2620 static int
2621 validate_offset_imm (val, hwse)
2622      unsigned int val;
2623      int hwse;
2624 {
2625   if ((hwse && val > 255) || val > 4095)
2626     return FAIL;
2627   return val;
2628 }
2629
2630 static void
2631 s_req (a)
2632      int a ATTRIBUTE_UNUSED;
2633 {
2634   as_bad (_("invalid syntax for .req directive"));
2635 }
2636
2637 static void
2638 s_bss (ignore)
2639      int ignore ATTRIBUTE_UNUSED;
2640 {
2641   /* We don't support putting frags in the BSS segment, we fake it by
2642      marking in_bss, then looking at s_skip for clues.  */
2643   subseg_set (bss_section, 0);
2644   demand_empty_rest_of_line ();
2645 }
2646
2647 static void
2648 s_even (ignore)
2649      int ignore ATTRIBUTE_UNUSED;
2650 {
2651   /* Never make frag if expect extra pass.  */
2652   if (!need_pass_2)
2653     frag_align (1, 0, 0);
2654
2655   record_alignment (now_seg, 1);
2656
2657   demand_empty_rest_of_line ();
2658 }
2659
2660 static void
2661 s_ltorg (ignored)
2662      int ignored ATTRIBUTE_UNUSED;
2663 {
2664   unsigned int entry;
2665   literal_pool * pool;
2666   char sym_name[20];
2667
2668   pool = find_literal_pool ();
2669   if (pool == NULL
2670       || pool->symbol == NULL
2671       || pool->next_free_entry == 0)
2672     return;
2673
2674   /* Align pool as you have word accesses.
2675      Only make a frag if we have to.  */
2676   if (!need_pass_2)
2677     frag_align (2, 0, 0);
2678
2679   record_alignment (now_seg, 2);
2680
2681   sprintf (sym_name, "$$lit_\002%x", pool->id);
2682
2683   symbol_locate (pool->symbol, sym_name, now_seg,
2684                  (valueT) frag_now_fix (), frag_now);
2685   symbol_table_insert (pool->symbol);
2686
2687   ARM_SET_THUMB (pool->symbol, thumb_mode);
2688
2689 #if defined OBJ_COFF || defined OBJ_ELF
2690   ARM_SET_INTERWORK (pool->symbol, support_interwork);
2691 #endif
2692
2693   for (entry = 0; entry < pool->next_free_entry; entry ++)
2694     /* First output the expression in the instruction to the pool.  */
2695     emit_expr (&(pool->literals[entry]), 4); /* .word  */
2696
2697   /* Mark the pool as empty.  */
2698   pool->next_free_entry = 0;
2699   pool->symbol = NULL;
2700 }
2701
2702 /* Same as s_align_ptwo but align 0 => align 2.  */
2703
2704 static void
2705 s_align (unused)
2706      int unused ATTRIBUTE_UNUSED;
2707 {
2708   register int temp;
2709   register long temp_fill;
2710   long max_alignment = 15;
2711
2712   temp = get_absolute_expression ();
2713   if (temp > max_alignment)
2714     as_bad (_("alignment too large: %d assumed"), temp = max_alignment);
2715   else if (temp < 0)
2716     {
2717       as_bad (_("alignment negative. 0 assumed."));
2718       temp = 0;
2719     }
2720
2721   if (*input_line_pointer == ',')
2722     {
2723       input_line_pointer++;
2724       temp_fill = get_absolute_expression ();
2725     }
2726   else
2727     temp_fill = 0;
2728
2729   if (!temp)
2730     temp = 2;
2731
2732   /* Only make a frag if we HAVE to.  */
2733   if (temp && !need_pass_2)
2734     frag_align (temp, (int) temp_fill, 0);
2735   demand_empty_rest_of_line ();
2736
2737   record_alignment (now_seg, temp);
2738 }
2739
2740 static void
2741 s_force_thumb (ignore)
2742      int ignore ATTRIBUTE_UNUSED;
2743 {
2744   /* If we are not already in thumb mode go into it, EVEN if
2745      the target processor does not support thumb instructions.
2746      This is used by gcc/config/arm/lib1funcs.asm for example
2747      to compile interworking support functions even if the
2748      target processor should not support interworking.  */
2749   if (! thumb_mode)
2750     {
2751       thumb_mode = 2;
2752
2753       record_alignment (now_seg, 1);
2754     }
2755
2756   demand_empty_rest_of_line ();
2757 }
2758
2759 static void
2760 s_thumb_func (ignore)
2761      int ignore ATTRIBUTE_UNUSED;
2762 {
2763   if (! thumb_mode)
2764     opcode_select (16);
2765
2766   /* The following label is the name/address of the start of a Thumb function.
2767      We need to know this for the interworking support.  */
2768   label_is_thumb_function_name = TRUE;
2769
2770   demand_empty_rest_of_line ();
2771 }
2772
2773 /* Perform a .set directive, but also mark the alias as
2774    being a thumb function.  */
2775
2776 static void
2777 s_thumb_set (equiv)
2778      int equiv;
2779 {
2780   /* XXX the following is a duplicate of the code for s_set() in read.c
2781      We cannot just call that code as we need to get at the symbol that
2782      is created.  */
2783   register char *    name;
2784   register char      delim;
2785   register char *    end_name;
2786   register symbolS * symbolP;
2787
2788   /* Especial apologies for the random logic:
2789      This just grew, and could be parsed much more simply!
2790      Dean - in haste.  */
2791   name      = input_line_pointer;
2792   delim     = get_symbol_end ();
2793   end_name  = input_line_pointer;
2794   *end_name = delim;
2795
2796   SKIP_WHITESPACE ();
2797
2798   if (*input_line_pointer != ',')
2799     {
2800       *end_name = 0;
2801       as_bad (_("expected comma after name \"%s\""), name);
2802       *end_name = delim;
2803       ignore_rest_of_line ();
2804       return;
2805     }
2806
2807   input_line_pointer++;
2808   *end_name = 0;
2809
2810   if (name[0] == '.' && name[1] == '\0')
2811     {
2812       /* XXX - this should not happen to .thumb_set.  */
2813       abort ();
2814     }
2815
2816   if ((symbolP = symbol_find (name)) == NULL
2817       && (symbolP = md_undefined_symbol (name)) == NULL)
2818     {
2819 #ifndef NO_LISTING
2820       /* When doing symbol listings, play games with dummy fragments living
2821          outside the normal fragment chain to record the file and line info
2822          for this symbol.  */
2823       if (listing & LISTING_SYMBOLS)
2824         {
2825           extern struct list_info_struct * listing_tail;
2826           fragS * dummy_frag = (fragS *) xmalloc (sizeof (fragS));
2827
2828           memset (dummy_frag, 0, sizeof (fragS));
2829           dummy_frag->fr_type = rs_fill;
2830           dummy_frag->line = listing_tail;
2831           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2832           dummy_frag->fr_symbol = symbolP;
2833         }
2834       else
2835 #endif
2836         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2837
2838 #ifdef OBJ_COFF
2839       /* "set" symbols are local unless otherwise specified.  */
2840       SF_SET_LOCAL (symbolP);
2841 #endif /* OBJ_COFF  */
2842     }                           /* Make a new symbol.  */
2843
2844   symbol_table_insert (symbolP);
2845
2846   * end_name = delim;
2847
2848   if (equiv
2849       && S_IS_DEFINED (symbolP)
2850       && S_GET_SEGMENT (symbolP) != reg_section)
2851     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2852
2853   pseudo_set (symbolP);
2854
2855   demand_empty_rest_of_line ();
2856
2857   /* XXX Now we come to the Thumb specific bit of code.  */
2858
2859   THUMB_SET_FUNC (symbolP, 1);
2860   ARM_SET_THUMB (symbolP, 1);
2861 #if defined OBJ_ELF || defined OBJ_COFF
2862   ARM_SET_INTERWORK (symbolP, support_interwork);
2863 #endif
2864 }
2865
2866 static void
2867 opcode_select (width)
2868      int width;
2869 {
2870   switch (width)
2871     {
2872     case 16:
2873       if (! thumb_mode)
2874         {
2875           if (! (cpu_variant & ARM_EXT_V4T))
2876             as_bad (_("selected processor does not support THUMB opcodes"));
2877
2878           thumb_mode = 1;
2879           /* No need to force the alignment, since we will have been
2880              coming from ARM mode, which is word-aligned.  */
2881           record_alignment (now_seg, 1);
2882         }
2883       break;
2884
2885     case 32:
2886       if (thumb_mode)
2887         {
2888           if ((cpu_variant & ARM_ALL) == ARM_EXT_V4T)
2889             as_bad (_("selected processor does not support ARM opcodes"));
2890
2891           thumb_mode = 0;
2892
2893           if (!need_pass_2)
2894             frag_align (2, 0, 0);
2895
2896           record_alignment (now_seg, 1);
2897         }
2898       break;
2899
2900     default:
2901       as_bad (_("invalid instruction size selected (%d)"), width);
2902     }
2903 }
2904
2905 static void
2906 s_arm (ignore)
2907      int ignore ATTRIBUTE_UNUSED;
2908 {
2909   opcode_select (32);
2910   demand_empty_rest_of_line ();
2911 }
2912
2913 static void
2914 s_thumb (ignore)
2915      int ignore ATTRIBUTE_UNUSED;
2916 {
2917   opcode_select (16);
2918   demand_empty_rest_of_line ();
2919 }
2920
2921 static void
2922 s_code (unused)
2923      int unused ATTRIBUTE_UNUSED;
2924 {
2925   register int temp;
2926
2927   temp = get_absolute_expression ();
2928   switch (temp)
2929     {
2930     case 16:
2931     case 32:
2932       opcode_select (temp);
2933       break;
2934
2935     default:
2936       as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
2937     }
2938 }
2939
2940 static void
2941 end_of_line (str)
2942      char *str;
2943 {
2944   skip_whitespace (str);
2945
2946   if (*str != '\0' && !inst.error)
2947     inst.error = _("garbage following instruction");
2948 }
2949
2950 static int
2951 skip_past_comma (str)
2952      char ** str;
2953 {
2954   char * p = * str, c;
2955   int comma = 0;
2956
2957   while ((c = *p) == ' ' || c == ',')
2958     {
2959       p++;
2960       if (c == ',' && comma++)
2961         return FAIL;
2962     }
2963
2964   if (c == '\0')
2965     return FAIL;
2966
2967   *str = p;
2968   return comma ? SUCCESS : FAIL;
2969 }
2970
2971 /* A standard register must be given at this point.
2972    SHIFT is the place to put it in inst.instruction.
2973    Restores input start point on error.
2974    Returns the reg#, or FAIL.  */
2975
2976 static int
2977 reg_required_here (str, shift)
2978      char ** str;
2979      int     shift;
2980 {
2981   static char buff [128]; /* XXX  */
2982   int         reg;
2983   char *      start = * str;
2984
2985   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_RN].htab)) != FAIL)
2986     {
2987       if (shift >= 0)
2988         inst.instruction |= reg << shift;
2989       return reg;
2990     }
2991
2992   /* Restore the start point, we may have got a reg of the wrong class.  */
2993   *str = start;
2994
2995   /* In the few cases where we might be able to accept something else
2996      this error can be overridden.  */
2997   sprintf (buff, _("register expected, not '%.100s'"), start);
2998   inst.error = buff;
2999
3000   return FAIL;
3001 }
3002
3003 /* A Intel Wireless MMX technology register
3004    must be given at this point.
3005    Shift is the place to put it in inst.instruction.
3006    Restores input start point on err.
3007    Returns the reg#, or FAIL.  */
3008
3009 static int
3010 wreg_required_here (str, shift, reg_type)
3011      char ** str;
3012      int     shift;
3013      enum wreg_type reg_type;
3014 {
3015   static char buff [128];
3016   int    reg;
3017   char * start = *str;
3018
3019   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_IWMMXT].htab)) != FAIL)
3020     {
3021       if (wr_register (reg)
3022           && (reg_type == IWMMXT_REG_WR || reg_type == IWMMXT_REG_WR_OR_WC))
3023         {
3024           if (shift >= 0)
3025             inst.instruction |= (reg ^ WR_PREFIX) << shift;
3026           return reg;
3027         }
3028       else if (wc_register (reg)
3029                && (reg_type == IWMMXT_REG_WC || reg_type == IWMMXT_REG_WR_OR_WC))
3030         {
3031           if (shift >= 0)
3032             inst.instruction |= (reg ^ WC_PREFIX) << shift;
3033           return reg;
3034         }
3035       else if ((wcg_register (reg) && reg_type == IWMMXT_REG_WCG))
3036         {
3037           if (shift >= 0)
3038             inst.instruction |= ((reg ^ WC_PREFIX) - 8) << shift;
3039           return reg;
3040         }
3041     }
3042
3043   /* Restore the start point, we may have got a reg of the wrong class.  */
3044   *str = start;
3045
3046   /* In the few cases where we might be able to accept
3047      something else this error can be overridden.  */
3048   sprintf (buff, _("Intel Wireless MMX technology register expected, not '%.100s'"), start);
3049   inst.error = buff;
3050
3051   return FAIL;
3052 }
3053
3054 static const struct asm_psr *
3055 arm_psr_parse (ccp)
3056      register char ** ccp;
3057 {
3058   char * start = * ccp;
3059   char   c;
3060   char * p;
3061   const struct asm_psr * psr;
3062
3063   p = start;
3064
3065   /* Skip to the end of the next word in the input stream.  */
3066   do
3067     {
3068       c = *p++;
3069     }
3070   while (ISALPHA (c) || c == '_');
3071
3072   /* Terminate the word.  */
3073   *--p = 0;
3074
3075   /* CPSR's and SPSR's can now be lowercase.  This is just a convenience
3076      feature for ease of use and backwards compatibility.  */
3077   if (!strncmp (start, "cpsr", 4))
3078     strncpy (start, "CPSR", 4);
3079   else if (!strncmp (start, "spsr", 4))
3080     strncpy (start, "SPSR", 4);
3081
3082   /* Now locate the word in the psr hash table.  */
3083   psr = (const struct asm_psr *) hash_find (arm_psr_hsh, start);
3084
3085   /* Restore the input stream.  */
3086   *p = c;
3087
3088   /* If we found a valid match, advance the
3089      stream pointer past the end of the word.  */
3090   *ccp = p;
3091
3092   return psr;
3093 }
3094
3095 /* Parse the input looking for a PSR flag.  */
3096
3097 static int
3098 psr_required_here (str)
3099      char ** str;
3100 {
3101   char * start = * str;
3102   const struct asm_psr * psr;
3103
3104   psr = arm_psr_parse (str);
3105
3106   if (psr)
3107     {
3108       /* If this is the SPSR that is being modified, set the R bit.  */
3109       if (! psr->cpsr)
3110         inst.instruction |= SPSR_BIT;
3111
3112       /* Set the psr flags in the MSR instruction.  */
3113       inst.instruction |= psr->field << PSR_SHIFT;
3114
3115       return SUCCESS;
3116     }
3117
3118   /* In the few cases where we might be able to accept
3119      something else this error can be overridden.  */
3120   inst.error = _("flag for {c}psr instruction expected");
3121
3122   /* Restore the start point.  */
3123   *str = start;
3124   return FAIL;
3125 }
3126
3127 static int
3128 co_proc_number (str)
3129      char **str;
3130 {
3131   int processor, pchar;
3132   char *start;
3133
3134   skip_whitespace (*str);
3135   start = *str;
3136
3137   /* The data sheet seems to imply that just a number on its own is valid
3138      here, but the RISC iX assembler seems to accept a prefix 'p'.  We will
3139      accept either.  */
3140   if ((processor = arm_reg_parse (str, all_reg_maps[REG_TYPE_CP].htab))
3141       == FAIL)
3142     {
3143       *str = start;
3144
3145       pchar = *(*str)++;
3146       if (pchar >= '0' && pchar <= '9')
3147         {
3148           processor = pchar - '0';
3149           if (**str >= '0' && **str <= '9')
3150             {
3151               processor = processor * 10 + *(*str)++ - '0';
3152               if (processor > 15)
3153                 {
3154                   inst.error = _("illegal co-processor number");
3155                   return FAIL;
3156                 }
3157             }
3158         }
3159       else
3160         {
3161           inst.error = _("bad or missing co-processor number");
3162           return FAIL;
3163         }
3164     }
3165
3166   inst.instruction |= processor << 8;
3167   return SUCCESS;
3168 }
3169
3170 static int
3171 cp_opc_expr (str, where, length)
3172      char ** str;
3173      int where;
3174      int length;
3175 {
3176   expressionS expr;
3177
3178   skip_whitespace (* str);
3179
3180   memset (&expr, '\0', sizeof (expr));
3181
3182   if (my_get_expression (&expr, str))
3183     return FAIL;
3184   if (expr.X_op != O_constant)
3185     {
3186       inst.error = _("bad or missing expression");
3187       return FAIL;
3188     }
3189
3190   if ((expr.X_add_number & ((1 << length) - 1)) != expr.X_add_number)
3191     {
3192       inst.error = _("immediate co-processor expression too large");
3193       return FAIL;
3194     }
3195
3196   inst.instruction |= expr.X_add_number << where;
3197   return SUCCESS;
3198 }
3199
3200 static int
3201 cp_reg_required_here (str, where)
3202      char ** str;
3203      int     where;
3204 {
3205   int    reg;
3206   char * start = *str;
3207
3208   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_CN].htab)) != FAIL)
3209     {
3210       inst.instruction |= reg << where;
3211       return reg;
3212     }
3213
3214   /* In the few cases where we might be able to accept something else
3215      this error can be overridden.  */
3216   inst.error = _("co-processor register expected");
3217
3218   /* Restore the start point.  */
3219   *str = start;
3220   return FAIL;
3221 }
3222
3223 static int
3224 fp_reg_required_here (str, where)
3225      char ** str;
3226      int     where;
3227 {
3228   int    reg;
3229   char * start = * str;
3230
3231   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_FN].htab)) != FAIL)
3232     {
3233       inst.instruction |= reg << where;
3234       return reg;
3235     }
3236
3237   /* In the few cases where we might be able to accept something else
3238      this error can be overridden.  */
3239   inst.error = _("floating point register expected");
3240
3241   /* Restore the start point.  */
3242   *str = start;
3243   return FAIL;
3244 }
3245
3246 static int
3247 cp_address_offset (str)
3248      char ** str;
3249 {
3250   int offset;
3251
3252   skip_whitespace (* str);
3253
3254   if (! is_immediate_prefix (**str))
3255     {
3256       inst.error = _("immediate expression expected");
3257       return FAIL;
3258     }
3259
3260   (*str)++;
3261
3262   if (my_get_expression (& inst.reloc.exp, str))
3263     return FAIL;
3264
3265   if (inst.reloc.exp.X_op == O_constant)
3266     {
3267       offset = inst.reloc.exp.X_add_number;
3268
3269       if (offset & 3)
3270         {
3271           inst.error = _("co-processor address must be word aligned");
3272           return FAIL;
3273         }
3274
3275       if (offset > 1023 || offset < -1023)
3276         {
3277           inst.error = _("offset too large");
3278           return FAIL;
3279         }
3280
3281       if (offset >= 0)
3282         inst.instruction |= INDEX_UP;
3283       else
3284         offset = -offset;
3285
3286       inst.instruction |= offset >> 2;
3287     }
3288   else
3289     inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
3290
3291   return SUCCESS;
3292 }
3293
3294 static int
3295 cp_address_required_here (str, wb_ok)
3296      char ** str;
3297      int wb_ok;
3298 {
3299   char * p = * str;
3300   int    pre_inc = 0;
3301   int    write_back = 0;
3302
3303   if (*p == '[')
3304     {
3305       int reg;
3306
3307       p++;
3308       skip_whitespace (p);
3309
3310       if ((reg = reg_required_here (& p, 16)) == FAIL)
3311         return FAIL;
3312
3313       skip_whitespace (p);
3314
3315       if (*p == ']')
3316         {
3317           p++;
3318
3319           if (wb_ok && skip_past_comma (& p) == SUCCESS)
3320             {
3321               /* [Rn], #expr  */
3322               write_back = WRITE_BACK;
3323
3324               if (reg == REG_PC)
3325                 {
3326                   inst.error = _("pc may not be used in post-increment");
3327                   return FAIL;
3328                 }
3329
3330               if (cp_address_offset (& p) == FAIL)
3331                 return FAIL;
3332             }
3333           else
3334             pre_inc = PRE_INDEX | INDEX_UP;
3335         }
3336       else
3337         {
3338           /* '['Rn, #expr']'[!]  */
3339
3340           if (skip_past_comma (& p) == FAIL)
3341             {
3342               inst.error = _("pre-indexed expression expected");
3343               return FAIL;
3344             }
3345
3346           pre_inc = PRE_INDEX;
3347
3348           if (cp_address_offset (& p) == FAIL)
3349             return FAIL;
3350
3351           skip_whitespace (p);
3352
3353           if (*p++ != ']')
3354             {
3355               inst.error = _("missing ]");
3356               return FAIL;
3357             }
3358
3359           skip_whitespace (p);
3360
3361           if (wb_ok && *p == '!')
3362             {
3363               if (reg == REG_PC)
3364                 {
3365                   inst.error = _("pc may not be used with write-back");
3366                   return FAIL;
3367                 }
3368
3369               p++;
3370               write_back = WRITE_BACK;
3371             }
3372         }
3373     }
3374   else
3375     {
3376       if (my_get_expression (&inst.reloc.exp, &p))
3377         return FAIL;
3378
3379       inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
3380       inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust.  */
3381       inst.reloc.pc_rel = 1;
3382       inst.instruction |= (REG_PC << 16);
3383       pre_inc = PRE_INDEX;
3384     }
3385
3386   inst.instruction |= write_back | pre_inc;
3387   *str = p;
3388   return SUCCESS;
3389 }
3390
3391 static int
3392 cp_byte_address_offset (str)
3393      char ** str;
3394 {
3395   int offset;
3396
3397   skip_whitespace (* str);
3398
3399   if (! is_immediate_prefix (**str))
3400     {
3401       inst.error = _("immediate expression expected");
3402       return FAIL;
3403     }
3404
3405   (*str)++;
3406
3407   if (my_get_expression (& inst.reloc.exp, str))
3408     return FAIL;
3409
3410   if (inst.reloc.exp.X_op == O_constant)
3411     {
3412       offset = inst.reloc.exp.X_add_number;
3413
3414       if (offset > 255 || offset < -255)
3415         {
3416           inst.error = _("offset too large");
3417           return FAIL;
3418         }
3419
3420       if (offset >= 0)
3421         inst.instruction |= INDEX_UP;
3422       else
3423         offset = -offset;
3424
3425       inst.instruction |= offset;
3426     }
3427   else
3428     inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM_S2;
3429
3430   return SUCCESS;
3431 }
3432
3433 static int
3434 cp_byte_address_required_here (str)
3435      char ** str;
3436 {
3437   char * p = * str;
3438   int    pre_inc = 0;
3439   int    write_back = 0;
3440
3441   if (*p == '[')
3442     {
3443       int reg;
3444
3445       p++;
3446       skip_whitespace (p);
3447
3448       if ((reg = reg_required_here (& p, 16)) == FAIL)
3449         return FAIL;
3450
3451       skip_whitespace (p);
3452
3453       if (*p == ']')
3454         {
3455           p++;
3456
3457           if (skip_past_comma (& p) == SUCCESS)
3458             {
3459               /* [Rn], #expr */
3460               write_back = WRITE_BACK;
3461
3462               if (reg == REG_PC)
3463                 {
3464                   inst.error = _("pc may not be used in post-increment");
3465                   return FAIL;
3466                 }
3467
3468               if (cp_byte_address_offset (& p) == FAIL)
3469                 return FAIL;
3470             }
3471           else
3472             pre_inc = PRE_INDEX | INDEX_UP;
3473         }
3474       else
3475         {
3476           /* '['Rn, #expr']'[!] */
3477
3478           if (skip_past_comma (& p) == FAIL)
3479             {
3480               inst.error = _("pre-indexed expression expected");
3481               return FAIL;
3482             }
3483
3484           pre_inc = PRE_INDEX;
3485
3486           if (cp_byte_address_offset (& p) == FAIL)
3487             return FAIL;
3488
3489           skip_whitespace (p);
3490
3491           if (*p++ != ']')
3492             {
3493               inst.error = _("missing ]");
3494               return FAIL;
3495             }
3496
3497           skip_whitespace (p);
3498
3499           if (*p == '!')
3500             {
3501               if (reg == REG_PC)
3502                 {
3503                   inst.error = _("pc may not be used with write-back");
3504                   return FAIL;
3505                 }
3506
3507               p++;
3508               write_back = WRITE_BACK;
3509             }
3510         }
3511     }
3512   else
3513     {
3514       if (my_get_expression (&inst.reloc.exp, &p))
3515         return FAIL;
3516
3517       inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM_S2;
3518       inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust.  */
3519       inst.reloc.pc_rel = 1;
3520       inst.instruction |= (REG_PC << 16);
3521       pre_inc = PRE_INDEX;
3522     }
3523
3524   inst.instruction |= write_back | pre_inc;
3525   *str = p;
3526   return SUCCESS;
3527 }
3528
3529 static void
3530 do_empty (str)
3531      char * str;
3532 {
3533   /* Do nothing really.  */
3534   end_of_line (str);
3535   return;
3536 }
3537
3538 static void
3539 do_mrs (str)
3540      char *str;
3541 {
3542   int skip = 0;
3543
3544   /* Only one syntax.  */
3545   skip_whitespace (str);
3546
3547   if (reg_required_here (&str, 12) == FAIL)
3548     {
3549       inst.error = BAD_ARGS;
3550       return;
3551     }
3552
3553   if (skip_past_comma (&str) == FAIL)
3554     {
3555       inst.error = _("comma expected after register name");
3556       return;
3557     }
3558
3559   skip_whitespace (str);
3560
3561   if (   strcmp (str, "CPSR") == 0
3562       || strcmp (str, "SPSR") == 0
3563          /* Lower case versions for backwards compatability.  */
3564       || strcmp (str, "cpsr") == 0
3565       || strcmp (str, "spsr") == 0)
3566     skip = 4;
3567
3568   /* This is for backwards compatability with older toolchains.  */
3569   else if (   strcmp (str, "cpsr_all") == 0
3570            || strcmp (str, "spsr_all") == 0)
3571     skip = 8;
3572   else
3573     {
3574       inst.error = _("CPSR or SPSR expected");
3575       return;
3576     }
3577
3578   if (* str == 's' || * str == 'S')
3579     inst.instruction |= SPSR_BIT;
3580   str += skip;
3581
3582   end_of_line (str);
3583 }
3584
3585 /* Two possible forms:
3586       "{C|S}PSR_<field>, Rm",
3587       "{C|S}PSR_f, #expression".  */
3588
3589 static void
3590 do_msr (str)
3591      char * str;
3592 {
3593   skip_whitespace (str);
3594
3595   if (psr_required_here (& str) == FAIL)
3596     return;
3597
3598   if (skip_past_comma (& str) == FAIL)
3599     {
3600       inst.error = _("comma missing after psr flags");
3601       return;
3602     }
3603
3604   skip_whitespace (str);
3605
3606   if (reg_required_here (& str, 0) != FAIL)
3607     {
3608       inst.error = NULL;
3609       end_of_line (str);
3610       return;
3611     }
3612
3613   if (! is_immediate_prefix (* str))
3614     {
3615       inst.error =
3616         _("only a register or immediate value can follow a psr flag");
3617       return;
3618     }
3619
3620   str ++;
3621   inst.error = NULL;
3622
3623   if (my_get_expression (& inst.reloc.exp, & str))
3624     {
3625       inst.error =
3626         _("only a register or immediate value can follow a psr flag");
3627       return;
3628     }
3629
3630 #if 0  /* The first edition of the ARM architecture manual stated that
3631           writing anything other than the flags with an immediate operation
3632           had UNPREDICTABLE effects.  This constraint was removed in the
3633           second edition of the specification.  */
3634   if ((cpu_variant & ARM_EXT_V5) != ARM_EXT_V5
3635       && inst.instruction & ((PSR_c | PSR_x | PSR_s) << PSR_SHIFT))
3636     {
3637       inst.error = _("immediate value cannot be used to set this field");
3638       return;
3639     }
3640 #endif
3641
3642   inst.instruction |= INST_IMMEDIATE;
3643
3644   if (inst.reloc.exp.X_add_symbol)
3645     {
3646       inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
3647       inst.reloc.pc_rel = 0;
3648     }
3649   else
3650     {
3651       unsigned value = validate_immediate (inst.reloc.exp.X_add_number);
3652
3653       if (value == (unsigned) FAIL)
3654         {
3655           inst.error = _("invalid constant");
3656           return;
3657         }
3658
3659       inst.instruction |= value;
3660     }
3661
3662   inst.error = NULL;
3663   end_of_line (str);
3664 }
3665
3666 /* Long Multiply Parser
3667    UMULL RdLo, RdHi, Rm, Rs
3668    SMULL RdLo, RdHi, Rm, Rs
3669    UMLAL RdLo, RdHi, Rm, Rs
3670    SMLAL RdLo, RdHi, Rm, Rs.  */
3671
3672 static void
3673 do_mull (str)
3674      char * str;
3675 {
3676   int rdlo, rdhi, rm, rs;
3677
3678   /* Only one format "rdlo, rdhi, rm, rs".  */
3679   skip_whitespace (str);
3680
3681   if ((rdlo = reg_required_here (&str, 12)) == FAIL)
3682     {
3683       inst.error = BAD_ARGS;
3684       return;
3685     }
3686
3687   if (skip_past_comma (&str) == FAIL
3688       || (rdhi = reg_required_here (&str, 16)) == FAIL)
3689     {
3690       inst.error = BAD_ARGS;
3691       return;
3692     }
3693
3694   if (skip_past_comma (&str) == FAIL
3695       || (rm = reg_required_here (&str, 0)) == FAIL)
3696     {
3697       inst.error = BAD_ARGS;
3698       return;
3699     }
3700
3701   /* rdhi, rdlo and rm must all be different.  */
3702   if (rdlo == rdhi || rdlo == rm || rdhi == rm)
3703     as_tsktsk (_("rdhi, rdlo and rm must all be different"));
3704
3705   if (skip_past_comma (&str) == FAIL
3706       || (rs = reg_required_here (&str, 8)) == FAIL)
3707     {
3708       inst.error = BAD_ARGS;
3709       return;
3710     }
3711
3712   if (rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC)
3713     {
3714       inst.error = BAD_PC;
3715       return;
3716     }
3717
3718   end_of_line (str);
3719   return;
3720 }
3721
3722 static void
3723 do_mul (str)
3724      char * str;
3725 {
3726   int rd, rm;
3727
3728   /* Only one format "rd, rm, rs".  */
3729   skip_whitespace (str);
3730
3731   if ((rd = reg_required_here (&str, 16)) == FAIL)
3732     {
3733       inst.error = BAD_ARGS;
3734       return;
3735     }
3736
3737   if (rd == REG_PC)
3738     {
3739       inst.error = BAD_PC;
3740       return;
3741     }
3742
3743   if (skip_past_comma (&str) == FAIL
3744       || (rm = reg_required_here (&str, 0)) == FAIL)
3745     {
3746       inst.error = BAD_ARGS;
3747       return;
3748     }
3749
3750   if (rm == REG_PC)
3751     {
3752       inst.error = BAD_PC;
3753       return;
3754     }
3755
3756   if (rm == rd)
3757     as_tsktsk (_("rd and rm should be different in mul"));
3758
3759   if (skip_past_comma (&str) == FAIL
3760       || (rm = reg_required_here (&str, 8)) == FAIL)
3761     {
3762       inst.error = BAD_ARGS;
3763       return;
3764     }
3765
3766   if (rm == REG_PC)
3767     {
3768       inst.error = BAD_PC;
3769       return;
3770     }
3771
3772   end_of_line (str);
3773   return;
3774 }
3775
3776 static void
3777 do_mla (str)
3778      char * str;
3779 {
3780   int rd, rm;
3781
3782   /* Only one format "rd, rm, rs, rn".  */
3783   skip_whitespace (str);
3784
3785   if ((rd = reg_required_here (&str, 16)) == FAIL)
3786     {
3787       inst.error = BAD_ARGS;
3788       return;
3789     }
3790
3791   if (rd == REG_PC)
3792     {
3793       inst.error = BAD_PC;
3794       return;
3795     }
3796
3797   if (skip_past_comma (&str) == FAIL
3798       || (rm = reg_required_here (&str, 0)) == FAIL)
3799     {
3800       inst.error = BAD_ARGS;
3801       return;
3802     }
3803
3804   if (rm == REG_PC)
3805     {
3806       inst.error = BAD_PC;
3807       return;
3808     }
3809
3810   if (rm == rd)
3811     as_tsktsk (_("rd and rm should be different in mla"));
3812
3813   if (skip_past_comma (&str) == FAIL
3814       || (rd = reg_required_here (&str, 8)) == FAIL
3815       || skip_past_comma (&str) == FAIL
3816       || (rm = reg_required_here (&str, 12)) == FAIL)
3817     {
3818       inst.error = BAD_ARGS;
3819       return;
3820     }
3821
3822   if (rd == REG_PC || rm == REG_PC)
3823     {
3824       inst.error = BAD_PC;
3825       return;
3826     }
3827
3828   end_of_line (str);
3829   return;
3830 }
3831
3832 /* Expects *str -> the characters "acc0", possibly with leading blanks.
3833    Advances *str to the next non-alphanumeric.
3834    Returns 0, or else FAIL (in which case sets inst.error).
3835
3836   (In a future XScale, there may be accumulators other than zero.
3837   At that time this routine and its callers can be upgraded to suit.)  */
3838
3839 static int
3840 accum0_required_here (str)
3841      char ** str;
3842 {
3843   static char buff [128];       /* Note the address is taken.  Hence, static.  */
3844   char * p = * str;
3845   char   c;
3846   int result = 0;               /* The accum number.  */
3847
3848   skip_whitespace (p);
3849
3850   *str = p;                     /* Advance caller's string pointer too.  */
3851   c = *p++;
3852   while (ISALNUM (c))
3853     c = *p++;
3854
3855   *--p = 0;                     /* Aap nul into input buffer at non-alnum.  */
3856
3857   if (! ( streq (*str, "acc0") || streq (*str, "ACC0")))
3858     {
3859       sprintf (buff, _("acc0 expected, not '%.100s'"), *str);
3860       inst.error = buff;
3861       result = FAIL;
3862     }
3863
3864   *p = c;                       /* Unzap.  */
3865   *str = p;                     /* Caller's string pointer to after match.  */
3866   return result;
3867 }
3868
3869 /* Expects **str -> after a comma. May be leading blanks.
3870    Advances *str, recognizing a load  mode, and setting inst.instruction.
3871    Returns rn, or else FAIL (in which case may set inst.error
3872    and not advance str)
3873
3874    Note: doesn't know Rd, so no err checks that require such knowledge.  */
3875
3876 static int
3877 ld_mode_required_here (string)
3878      char ** string;
3879 {
3880   char * str = * string;
3881   int    rn;
3882   int    pre_inc = 0;
3883
3884   skip_whitespace (str);
3885
3886   if (* str == '[')
3887     {
3888       str++;
3889
3890       skip_whitespace (str);
3891
3892       if ((rn = reg_required_here (& str, 16)) == FAIL)
3893         return FAIL;
3894
3895       skip_whitespace (str);
3896
3897       if (* str == ']')
3898         {
3899           str ++;
3900
3901           if (skip_past_comma (& str) == SUCCESS)
3902             {
3903               /* [Rn],... (post inc) */
3904               if (ldst_extend_v4 (&str) == FAIL)
3905                 return FAIL;
3906             }
3907           else        /* [Rn] */
3908             {
3909               skip_whitespace (str);
3910
3911               if (* str == '!')
3912                 {
3913                   str ++;
3914                   inst.instruction |= WRITE_BACK;
3915                 }
3916
3917               inst.instruction |= INDEX_UP | HWOFFSET_IMM;
3918               pre_inc = 1;
3919             }
3920         }
3921       else        /* [Rn,...] */
3922         {
3923           if (skip_past_comma (& str) == FAIL)
3924             {
3925               inst.error = _("pre-indexed expression expected");
3926               return FAIL;
3927             }
3928
3929           pre_inc = 1;
3930
3931           if (ldst_extend_v4 (&str) == FAIL)
3932             return FAIL;
3933
3934           skip_whitespace (str);
3935
3936           if (* str ++ != ']')
3937             {
3938               inst.error = _("missing ]");
3939               return FAIL;
3940             }
3941
3942           skip_whitespace (str);
3943
3944           if (* str == '!')
3945             {
3946               str ++;
3947               inst.instruction |= WRITE_BACK;
3948             }
3949         }
3950     }
3951   else if (* str == '=')        /* ldr's "r,=label" syntax */
3952     /* We should never reach here, because <text> = <expression> is
3953        caught gas/read.c read_a_source_file() as a .set operation.  */
3954     return FAIL;
3955   else                          /* PC +- 8 bit immediate offset.  */
3956     {
3957       if (my_get_expression (& inst.reloc.exp, & str))
3958         return FAIL;
3959
3960       inst.instruction            |= HWOFFSET_IMM;      /* The I bit.  */
3961       inst.reloc.type              = BFD_RELOC_ARM_OFFSET_IMM8;
3962       inst.reloc.exp.X_add_number -= 8;                 /* PC rel adjust.  */
3963       inst.reloc.pc_rel            = 1;
3964       inst.instruction            |= (REG_PC << 16);
3965
3966       rn = REG_PC;
3967       pre_inc = 1;
3968     }
3969
3970   inst.instruction |= (pre_inc ? PRE_INDEX : 0);
3971   * string = str;
3972
3973   return rn;
3974 }
3975
3976 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
3977    SMLAxy{cond} Rd,Rm,Rs,Rn
3978    SMLAWy{cond} Rd,Rm,Rs,Rn
3979    Error if any register is R15.  */
3980
3981 static void
3982 do_smla (str)
3983      char *        str;
3984 {
3985   int rd, rm, rs, rn;
3986
3987   skip_whitespace (str);
3988
3989   if ((rd = reg_required_here (& str, 16)) == FAIL
3990       || skip_past_comma (& str) == FAIL
3991       || (rm = reg_required_here (& str, 0)) == FAIL
3992       || skip_past_comma (& str) == FAIL
3993       || (rs = reg_required_here (& str, 8)) == FAIL
3994       || skip_past_comma (& str) == FAIL
3995       || (rn = reg_required_here (& str, 12)) == FAIL)
3996     inst.error = BAD_ARGS;
3997
3998   else if (rd == REG_PC || rm == REG_PC || rs == REG_PC || rn == REG_PC)
3999     inst.error = BAD_PC;
4000
4001   else
4002     end_of_line (str);
4003 }
4004
4005 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
4006    SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
4007    Error if any register is R15.
4008    Warning if Rdlo == Rdhi.  */
4009
4010 static void
4011 do_smlal (str)
4012      char *        str;
4013 {
4014   int rdlo, rdhi, rm, rs;
4015
4016   skip_whitespace (str);
4017
4018   if ((rdlo = reg_required_here (& str, 12)) == FAIL
4019       || skip_past_comma (& str) == FAIL
4020       || (rdhi = reg_required_here (& str, 16)) == FAIL
4021       || skip_past_comma (& str) == FAIL
4022       || (rm = reg_required_here (& str, 0)) == FAIL
4023       || skip_past_comma (& str) == FAIL
4024       || (rs = reg_required_here (& str, 8)) == FAIL)
4025     {
4026       inst.error = BAD_ARGS;
4027       return;
4028     }
4029
4030   if (rdlo == REG_PC || rdhi == REG_PC || rm == REG_PC || rs == REG_PC)
4031     {
4032       inst.error = BAD_PC;
4033       return;
4034     }
4035
4036   if (rdlo == rdhi)
4037     as_tsktsk (_("rdhi and rdlo must be different"));
4038
4039   end_of_line (str);
4040 }
4041
4042 /* ARM V5E (El Segundo) signed-multiply (argument parse)
4043    SMULxy{cond} Rd,Rm,Rs
4044    Error if any register is R15.  */
4045
4046 static void
4047 do_smul (str)
4048      char *        str;
4049 {
4050   int rd, rm, rs;
4051
4052   skip_whitespace (str);
4053
4054   if ((rd = reg_required_here (& str, 16)) == FAIL
4055       || skip_past_comma (& str) == FAIL
4056       || (rm = reg_required_here (& str, 0)) == FAIL
4057       || skip_past_comma (& str) == FAIL
4058       || (rs = reg_required_here (& str, 8)) == FAIL)
4059     inst.error = BAD_ARGS;
4060
4061   else if (rd == REG_PC || rm == REG_PC || rs == REG_PC)
4062     inst.error = BAD_PC;
4063
4064   else
4065     end_of_line (str);
4066 }
4067
4068 /* ARM V5E (El Segundo) saturating-add/subtract (argument parse)
4069    Q[D]{ADD,SUB}{cond} Rd,Rm,Rn
4070    Error if any register is R15.  */
4071
4072 static void
4073 do_qadd (str)
4074      char *        str;
4075 {
4076   int rd, rm, rn;
4077
4078   skip_whitespace (str);
4079
4080   if ((rd = reg_required_here (& str, 12)) == FAIL
4081       || skip_past_comma (& str) == FAIL
4082       || (rm = reg_required_here (& str, 0)) == FAIL
4083       || skip_past_comma (& str) == FAIL
4084       || (rn = reg_required_here (& str, 16)) == FAIL)
4085     inst.error = BAD_ARGS;
4086
4087   else if (rd == REG_PC || rm == REG_PC || rn == REG_PC)
4088     inst.error = BAD_PC;
4089
4090   else
4091     end_of_line (str);
4092 }
4093
4094 /* ARM V5E (el Segundo)
4095    MCRRcc <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
4096    MRRCcc <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
4097
4098    These are equivalent to the XScale instructions MAR and MRA,
4099    respectively, when coproc == 0, opcode == 0, and CRm == 0.
4100
4101    Result unpredicatable if Rd or Rn is R15.  */
4102
4103 static void
4104 do_co_reg2c (str)
4105      char *        str;
4106 {
4107   int rd, rn;
4108
4109   skip_whitespace (str);
4110
4111   if (co_proc_number (& str) == FAIL)
4112     {
4113       if (!inst.error)
4114         inst.error = BAD_ARGS;
4115       return;
4116     }
4117
4118   if (skip_past_comma (& str) == FAIL
4119       || cp_opc_expr (& str, 4, 4) == FAIL)
4120     {
4121       if (!inst.error)
4122         inst.error = BAD_ARGS;
4123       return;
4124     }
4125
4126   if (skip_past_comma (& str) == FAIL
4127       || (rd = reg_required_here (& str, 12)) == FAIL)
4128     {
4129       if (!inst.error)
4130         inst.error = BAD_ARGS;
4131       return;
4132     }
4133
4134   if (skip_past_comma (& str) == FAIL
4135       || (rn = reg_required_here (& str, 16)) == FAIL)
4136     {
4137       if (!inst.error)
4138         inst.error = BAD_ARGS;
4139       return;
4140     }
4141
4142   /* Unpredictable result if rd or rn is R15.  */
4143   if (rd == REG_PC || rn == REG_PC)
4144     as_tsktsk
4145       (_("Warning: instruction unpredictable when using r15"));
4146
4147   if (skip_past_comma (& str) == FAIL
4148       || cp_reg_required_here (& str, 0) == FAIL)
4149     {
4150       if (!inst.error)
4151         inst.error = BAD_ARGS;
4152       return;
4153     }
4154
4155   end_of_line (str);
4156 }
4157
4158 /* ARM V5 count-leading-zeroes instruction (argument parse)
4159      CLZ{<cond>} <Rd>, <Rm>
4160      Condition defaults to COND_ALWAYS.
4161      Error if Rd or Rm are R15.  */
4162
4163 static void
4164 do_clz (str)
4165      char *        str;
4166 {
4167   int rd, rm;
4168
4169   skip_whitespace (str);
4170
4171   if (((rd = reg_required_here (& str, 12)) == FAIL)
4172       || (skip_past_comma (& str) == FAIL)
4173       || ((rm = reg_required_here (& str, 0)) == FAIL))
4174     inst.error = BAD_ARGS;
4175
4176   else if (rd == REG_PC || rm == REG_PC )
4177     inst.error = BAD_PC;
4178
4179   else
4180     end_of_line (str);
4181 }
4182
4183 /* ARM V5 (argument parse)
4184      LDC2{L} <coproc>, <CRd>, <addressing mode>
4185      STC2{L} <coproc>, <CRd>, <addressing mode>
4186      Instruction is not conditional, and has 0xf in the codition field.
4187      Otherwise, it's the same as LDC/STC.  */
4188
4189 static void
4190 do_lstc2 (str)
4191      char *        str;
4192 {
4193   skip_whitespace (str);
4194
4195   if (co_proc_number (& str) == FAIL)
4196     {
4197       if (!inst.error)
4198         inst.error = BAD_ARGS;
4199     }
4200   else if (skip_past_comma (& str) == FAIL
4201            || cp_reg_required_here (& str, 12) == FAIL)
4202     {
4203       if (!inst.error)
4204         inst.error = BAD_ARGS;
4205     }
4206   else if (skip_past_comma (& str) == FAIL
4207            || cp_address_required_here (&str, CP_WB_OK) == FAIL)
4208     {
4209       if (! inst.error)
4210         inst.error = BAD_ARGS;
4211     }
4212   else
4213     end_of_line (str);
4214 }
4215
4216 /* ARM V5 (argument parse)
4217      CDP2 <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>, <opcode_2>
4218      Instruction is not conditional, and has 0xf in the condition field.
4219      Otherwise, it's the same as CDP.  */
4220
4221 static void
4222 do_cdp2 (str)
4223      char *        str;
4224 {
4225   skip_whitespace (str);
4226
4227   if (co_proc_number (& str) == FAIL)
4228     {
4229       if (!inst.error)
4230         inst.error = BAD_ARGS;
4231       return;
4232     }
4233
4234   if (skip_past_comma (& str) == FAIL
4235       || cp_opc_expr (& str, 20,4) == FAIL)
4236     {
4237       if (!inst.error)
4238         inst.error = BAD_ARGS;
4239       return;
4240     }
4241
4242   if (skip_past_comma (& str) == FAIL
4243       || cp_reg_required_here (& str, 12) == FAIL)
4244     {
4245       if (!inst.error)
4246         inst.error = BAD_ARGS;
4247       return;
4248     }
4249
4250   if (skip_past_comma (& str) == FAIL
4251       || cp_reg_required_here (& str, 16) == FAIL)
4252     {
4253       if (!inst.error)
4254         inst.error = BAD_ARGS;
4255       return;
4256     }
4257
4258   if (skip_past_comma (& str) == FAIL
4259       || cp_reg_required_here (& str, 0) == FAIL)
4260     {
4261       if (!inst.error)
4262         inst.error = BAD_ARGS;
4263       return;
4264     }
4265
4266   if (skip_past_comma (& str) == SUCCESS)
4267     {
4268       if (cp_opc_expr (& str, 5, 3) == FAIL)
4269         {
4270           if (!inst.error)
4271             inst.error = BAD_ARGS;
4272           return;
4273         }
4274     }
4275
4276   end_of_line (str);
4277 }
4278
4279 /* ARM V5 (argument parse)
4280      MCR2 <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, <opcode_2>
4281      MRC2 <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, <opcode_2>
4282      Instruction is not conditional, and has 0xf in the condition field.
4283      Otherwise, it's the same as MCR/MRC.  */
4284
4285 static void
4286 do_co_reg2 (str)
4287      char *        str;
4288 {
4289   skip_whitespace (str);
4290
4291   if (co_proc_number (& str) == FAIL)
4292     {
4293       if (!inst.error)
4294         inst.error = BAD_ARGS;
4295       return;
4296     }
4297
4298   if (skip_past_comma (& str) == FAIL
4299       || cp_opc_expr (& str, 21, 3) == FAIL)
4300     {
4301       if (!inst.error)
4302         inst.error = BAD_ARGS;
4303       return;
4304     }
4305
4306   if (skip_past_comma (& str) == FAIL
4307       || reg_required_here (& str, 12) == FAIL)
4308     {
4309       if (!inst.error)
4310         inst.error = BAD_ARGS;
4311       return;
4312     }
4313
4314   if (skip_past_comma (& str) == FAIL
4315       || cp_reg_required_here (& str, 16) == FAIL)
4316     {
4317       if (!inst.error)
4318         inst.error = BAD_ARGS;
4319       return;
4320     }
4321
4322   if (skip_past_comma (& str) == FAIL
4323       || cp_reg_required_here (& str, 0) == FAIL)
4324     {
4325       if (!inst.error)
4326         inst.error = BAD_ARGS;
4327       return;
4328     }
4329
4330   if (skip_past_comma (& str) == SUCCESS)
4331     {
4332       if (cp_opc_expr (& str, 5, 3) == FAIL)
4333         {
4334           if (!inst.error)
4335             inst.error = BAD_ARGS;
4336           return;
4337         }
4338     }
4339
4340   end_of_line (str);
4341 }
4342
4343 /* ARM v5TEJ.  Jump to Jazelle code.  */
4344 static void
4345 do_bxj (str)
4346      char * str;
4347 {
4348   int reg;
4349
4350   skip_whitespace (str);
4351
4352   if ((reg = reg_required_here (&str, 0)) == FAIL)
4353     {
4354       inst.error = BAD_ARGS;
4355       return;
4356     }
4357
4358   /* Note - it is not illegal to do a "bxj pc".  Useless, but not illegal.  */
4359   if (reg == REG_PC)
4360     as_tsktsk (_("use of r15 in bxj is not really useful"));
4361
4362   end_of_line (str);
4363 }
4364
4365 /* THUMB V5 breakpoint instruction (argument parse)
4366         BKPT <immed_8>.  */
4367
4368 static void
4369 do_t_bkpt (str)
4370      char * str;
4371 {
4372   expressionS expr;
4373   unsigned long number;
4374
4375   skip_whitespace (str);
4376
4377   /* Allow optional leading '#'.  */
4378   if (is_immediate_prefix (*str))
4379     str ++;
4380
4381   memset (& expr, '\0', sizeof (expr));
4382   if (my_get_expression (& expr, & str)
4383       || (expr.X_op != O_constant
4384           /* As a convenience we allow 'bkpt' without an operand.  */
4385           && expr.X_op != O_absent))
4386     {
4387       inst.error = _("bad expression");
4388       return;
4389     }
4390
4391   number = expr.X_add_number;
4392
4393   /* Check it fits an 8 bit unsigned.  */
4394   if (number != (number & 0xff))
4395     {
4396       inst.error = _("immediate value out of range");
4397       return;
4398     }
4399
4400   inst.instruction |= number;
4401
4402   end_of_line (str);
4403 }
4404
4405 /* ARM V5 branch-link-exchange (argument parse) for BLX(1) only.
4406    Expects inst.instruction is set for BLX(1).
4407    Note: this is cloned from do_branch, and the reloc changed to be a
4408         new one that can cope with setting one extra bit (the H bit).  */
4409
4410 static void
4411 do_branch25 (str)
4412      char *        str;
4413 {
4414   if (my_get_expression (& inst.reloc.exp, & str))
4415     return;
4416
4417 #ifdef OBJ_ELF
4418   {
4419     char * save_in;
4420
4421     /* ScottB: February 5, 1998 */
4422     /* Check to see of PLT32 reloc required for the instruction.  */
4423
4424     /* arm_parse_reloc() works on input_line_pointer.
4425        We actually want to parse the operands to the branch instruction
4426        passed in 'str'.  Save the input pointer and restore it later.  */
4427     save_in = input_line_pointer;
4428     input_line_pointer = str;
4429
4430     if (inst.reloc.exp.X_op == O_symbol
4431         && *str == '('
4432         && arm_parse_reloc () == BFD_RELOC_ARM_PLT32)
4433       {
4434         inst.reloc.type   = BFD_RELOC_ARM_PLT32;
4435         inst.reloc.pc_rel = 0;
4436         /* Modify str to point to after parsed operands, otherwise
4437            end_of_line() will complain about the (PLT) left in str.  */
4438         str = input_line_pointer;
4439       }
4440     else
4441       {
4442         inst.reloc.type   = BFD_RELOC_ARM_PCREL_BLX;
4443         inst.reloc.pc_rel = 1;
4444       }
4445
4446     input_line_pointer = save_in;
4447   }
4448 #else
4449   inst.reloc.type   = BFD_RELOC_ARM_PCREL_BLX;
4450   inst.reloc.pc_rel = 1;
4451 #endif /* OBJ_ELF */
4452
4453   end_of_line (str);
4454 }
4455
4456 /* ARM V5 branch-link-exchange instruction (argument parse)
4457      BLX <target_addr>          ie BLX(1)
4458      BLX{<condition>} <Rm>      ie BLX(2)
4459    Unfortunately, there are two different opcodes for this mnemonic.
4460    So, the insns[].value is not used, and the code here zaps values
4461         into inst.instruction.
4462    Also, the <target_addr> can be 25 bits, hence has its own reloc.  */
4463
4464 static void
4465 do_blx (str)
4466      char *        str;
4467 {
4468   char * mystr = str;
4469   int rm;
4470
4471   skip_whitespace (mystr);
4472   rm = reg_required_here (& mystr, 0);
4473
4474   /* The above may set inst.error.  Ignore his opinion.  */
4475   inst.error = 0;
4476
4477   if (rm != FAIL)
4478     {
4479       /* Arg is a register.
4480          Use the condition code our caller put in inst.instruction.
4481          Pass ourselves off as a BX with a funny opcode.  */
4482       inst.instruction |= 0x012fff30;
4483       do_bx (str);
4484     }
4485   else
4486     {
4487       /* This must be is BLX <target address>, no condition allowed.  */
4488       if (inst.instruction != COND_ALWAYS)
4489         {
4490           inst.error = BAD_COND;
4491           return;
4492         }
4493
4494       inst.instruction = 0xfafffffe;
4495
4496       /* Process like a B/BL, but with a different reloc.
4497          Note that B/BL expecte fffffe, not 0, offset in the opcode table.  */
4498       do_branch25 (str);
4499     }
4500 }
4501
4502 /* ARM V5 Thumb BLX (argument parse)
4503         BLX <target_addr>       which is BLX(1)
4504         BLX <Rm>                which is BLX(2)
4505    Unfortunately, there are two different opcodes for this mnemonic.
4506    So, the tinsns[].value is not used, and the code here zaps values
4507         into inst.instruction.  */
4508
4509 static void
4510 do_t_blx (str)
4511      char * str;
4512 {
4513   char * mystr = str;
4514   int rm;
4515
4516   skip_whitespace (mystr);
4517   inst.instruction = 0x4780;
4518
4519   /* Note that this call is to the ARM register recognizer.  BLX(2)
4520      uses the ARM register space, not the Thumb one, so a call to
4521      thumb_reg() would be wrong.  */
4522   rm = reg_required_here (& mystr, 3);
4523   inst.error = 0;
4524
4525   if (rm != FAIL)
4526     {
4527       /* It's BLX(2).  The .instruction was zapped with rm & is final.  */
4528       inst.size = 2;
4529     }
4530   else
4531     {
4532       /* No ARM register.  This must be BLX(1).  Change the .instruction.  */
4533       inst.instruction = 0xf7ffeffe;
4534       inst.size = 4;
4535
4536       if (my_get_expression (& inst.reloc.exp, & mystr))
4537         return;
4538
4539       inst.reloc.type   = BFD_RELOC_THUMB_PCREL_BLX;
4540       inst.reloc.pc_rel = 1;
4541     }
4542
4543   end_of_line (mystr);
4544 }
4545
4546 /* ARM V5 breakpoint instruction (argument parse)
4547      BKPT <16 bit unsigned immediate>
4548      Instruction is not conditional.
4549         The bit pattern given in insns[] has the COND_ALWAYS condition,
4550         and it is an error if the caller tried to override that.  */
4551
4552 static void
4553 do_bkpt (str)
4554      char *        str;
4555 {
4556   expressionS expr;
4557   unsigned long number;
4558
4559   skip_whitespace (str);
4560
4561   /* Allow optional leading '#'.  */
4562   if (is_immediate_prefix (* str))
4563     str++;
4564
4565   memset (& expr, '\0', sizeof (expr));
4566
4567   if (my_get_expression (& expr, & str)
4568       || (expr.X_op != O_constant
4569           /* As a convenience we allow 'bkpt' without an operand.  */
4570           && expr.X_op != O_absent))
4571     {
4572       inst.error = _("bad expression");
4573       return;
4574     }
4575
4576   number = expr.X_add_number;
4577
4578   /* Check it fits a 16 bit unsigned.  */
4579   if (number != (number & 0xffff))
4580     {
4581       inst.error = _("immediate value out of range");
4582       return;
4583     }
4584
4585   /* Top 12 of 16 bits to bits 19:8.  */
4586   inst.instruction |= (number & 0xfff0) << 4;
4587
4588   /* Bottom 4 of 16 bits to bits 3:0.  */
4589   inst.instruction |= number & 0xf;
4590
4591   end_of_line (str);
4592 }
4593
4594 static unsigned long check_iwmmxt_insn PARAMS ((char *, enum iwmmxt_insn_type, int));
4595
4596 /* Parse INSN_TYPE insn STR having a possible IMMEDIATE_SIZE immediate.  */
4597
4598 static unsigned long
4599 check_iwmmxt_insn (str, insn_type, immediate_size)
4600      char * str;
4601      enum iwmmxt_insn_type insn_type;
4602      int immediate_size;
4603 {
4604   int reg = 0;
4605   const char *  inst_error;
4606   expressionS expr;
4607   unsigned long number;
4608
4609   inst_error = inst.error;
4610   if (!inst.error)
4611     inst.error = BAD_ARGS;
4612   skip_whitespace (str);
4613
4614   switch (insn_type)
4615     {
4616     case check_rd:
4617       if ((reg = reg_required_here (&str, 12)) == FAIL)
4618         return FAIL;
4619       break;
4620
4621     case check_wr:
4622        if ((wreg_required_here (&str, 0, IWMMXT_REG_WR)) == FAIL)
4623          return FAIL;
4624        break;
4625
4626     case check_wrwr:
4627       if ((wreg_required_here (&str, 12, IWMMXT_REG_WR) == FAIL
4628            || skip_past_comma (&str) == FAIL
4629            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL))
4630         return FAIL;
4631       break;
4632
4633     case check_wrwrwr:
4634       if ((wreg_required_here (&str, 12, IWMMXT_REG_WR) == FAIL
4635            || skip_past_comma (&str) == FAIL
4636            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4637            || skip_past_comma (&str) == FAIL
4638            || wreg_required_here (&str, 0, IWMMXT_REG_WR) == FAIL))
4639         return FAIL;
4640       break;
4641
4642     case check_wrwrwcg:
4643       if ((wreg_required_here (&str, 12, IWMMXT_REG_WR) == FAIL
4644            || skip_past_comma (&str) == FAIL
4645            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4646            || skip_past_comma (&str) == FAIL
4647            || wreg_required_here (&str, 0, IWMMXT_REG_WCG) == FAIL))
4648         return FAIL;
4649       break;
4650
4651     case check_tbcst:
4652       if ((wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4653            || skip_past_comma (&str) == FAIL
4654            || reg_required_here (&str, 12) == FAIL))
4655         return FAIL;
4656       break;
4657
4658     case check_tmovmsk:
4659       if ((reg_required_here (&str, 12) == FAIL
4660            || skip_past_comma (&str) == FAIL
4661            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL))
4662         return FAIL;
4663       break;
4664
4665     case check_tmia:
4666       if ((wreg_required_here (&str, 5, IWMMXT_REG_WR) == FAIL
4667            || skip_past_comma (&str) == FAIL
4668            || reg_required_here (&str, 0) == FAIL
4669            || skip_past_comma (&str) == FAIL
4670            || reg_required_here (&str, 12) == FAIL))
4671         return FAIL;
4672       break;
4673
4674     case check_tmcrr:
4675       if ((wreg_required_here (&str, 0, IWMMXT_REG_WR) == FAIL
4676            || skip_past_comma (&str) == FAIL
4677            || reg_required_here (&str, 12) == FAIL
4678            || skip_past_comma (&str) == FAIL
4679            || reg_required_here (&str, 16) == FAIL))
4680         return FAIL;
4681       break;
4682
4683     case check_tmrrc:
4684       if ((reg_required_here (&str, 12) == FAIL
4685            || skip_past_comma (&str) == FAIL
4686            || reg_required_here (&str, 16) == FAIL
4687            || skip_past_comma (&str) == FAIL
4688            || wreg_required_here (&str, 0, IWMMXT_REG_WR) == FAIL))
4689         return FAIL;
4690       break;
4691
4692     case check_tmcr:
4693       if ((wreg_required_here (&str, 16, IWMMXT_REG_WC) == FAIL
4694            || skip_past_comma (&str) == FAIL
4695            || reg_required_here (&str, 12) == FAIL))
4696         return FAIL;
4697       break;
4698
4699     case check_tmrc:
4700       if ((reg_required_here (&str, 12) == FAIL
4701            || skip_past_comma (&str) == FAIL
4702            || wreg_required_here (&str, 16, IWMMXT_REG_WC) == FAIL))
4703         return FAIL;
4704       break;
4705
4706     case check_tinsr:
4707       if ((wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4708            || skip_past_comma (&str) == FAIL
4709            || reg_required_here (&str, 12) == FAIL
4710            || skip_past_comma (&str) == FAIL))
4711         return FAIL;
4712       break;
4713
4714     case check_textrc:
4715       if ((reg_required_here (&str, 12) == FAIL
4716            || skip_past_comma (&str) == FAIL))
4717         return FAIL;
4718       break;
4719
4720     case check_waligni:
4721       if ((wreg_required_here (&str, 12, IWMMXT_REG_WR) == FAIL
4722            || skip_past_comma (&str) == FAIL
4723            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4724            || skip_past_comma (&str) == FAIL
4725            || wreg_required_here (&str, 0, IWMMXT_REG_WR) == FAIL
4726            || skip_past_comma (&str) == FAIL))
4727         return FAIL;
4728       break;
4729
4730     case check_textrm:
4731       if ((reg_required_here (&str, 12) == FAIL
4732            || skip_past_comma (&str) == FAIL
4733            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4734            || skip_past_comma (&str) == FAIL))
4735         return FAIL;
4736       break;
4737
4738     case check_wshufh:
4739       if ((wreg_required_here (&str, 12, IWMMXT_REG_WR) == FAIL
4740            || skip_past_comma (&str) == FAIL
4741            || wreg_required_here (&str, 16, IWMMXT_REG_WR) == FAIL
4742            || skip_past_comma (&str) == FAIL))
4743         return FAIL;
4744       break;
4745     }
4746
4747   if (immediate_size == 0)
4748     {
4749       end_of_line (str);
4750       inst.error = inst_error;
4751       return reg;
4752     }
4753   else
4754     {
4755       skip_whitespace (str);
4756
4757       /* Allow optional leading '#'. */
4758       if (is_immediate_prefix (* str))
4759         str++;
4760
4761       memset (& expr, '\0', sizeof (expr));
4762
4763       if (my_get_expression (& expr, & str) || (expr.X_op != O_constant))
4764         {
4765           inst.error = _("bad or missing expression");
4766           return FAIL;
4767         }
4768
4769       number = expr.X_add_number;
4770
4771       if (number != (number & immediate_size))
4772         {
4773           inst.error = _("immediate value out of range");
4774           return FAIL;
4775         }
4776       end_of_line (str);
4777       inst.error = inst_error;
4778       return number;
4779     }
4780 }
4781
4782 static void
4783 do_iwmmxt_byte_addr (str)
4784      char * str;
4785 {
4786   int op = (inst.instruction & 0x300) >> 8;
4787   int reg;
4788
4789   inst.instruction &= ~0x300;
4790   inst.instruction |= (op & 1) << 22 | (op & 2) << 7;
4791
4792   skip_whitespace (str);
4793
4794   if ((reg = wreg_required_here (&str, 12, IWMMXT_REG_WR_OR_WC)) == FAIL
4795       || skip_past_comma (& str) == FAIL
4796       || cp_byte_address_required_here (&str) == FAIL)
4797     {
4798       if (! inst.error)
4799         inst.error = BAD_ARGS;
4800     }
4801   else
4802     end_of_line (str);
4803
4804   if (wc_register (reg))
4805     {
4806       inst.instruction |=  0xf0000100;
4807       inst.instruction &= ~0x00400000;
4808     }
4809 }
4810
4811 static void
4812 do_iwmmxt_tandc (str)
4813      char * str;
4814 {
4815   int reg;
4816
4817   reg = check_iwmmxt_insn (str, check_rd, 0);
4818
4819   if (reg != REG_PC && !inst.error)
4820     inst.error = _("only r15 allowed here");
4821   return;
4822 }
4823
4824 static void
4825 do_iwmmxt_tbcst (str)
4826      char * str;
4827 {
4828   check_iwmmxt_insn (str, check_tbcst, 0);
4829
4830   return;
4831 }
4832
4833 static void
4834 do_iwmmxt_textrc (str)
4835      char * str;
4836 {
4837   unsigned long number;
4838
4839   if ((number = check_iwmmxt_insn (str, check_textrc, 7)) == (unsigned long) FAIL)
4840     return;
4841
4842   inst.instruction |= number & 0x7;
4843   return;
4844 }
4845
4846 static void
4847 do_iwmmxt_textrm (str)
4848      char * str;
4849 {
4850   unsigned long number;
4851
4852   if ((number = check_iwmmxt_insn (str, check_textrm, 7)) == (unsigned long) FAIL)
4853     return;
4854
4855   inst.instruction |= number & 0x7;
4856 }
4857
4858 static void
4859 do_iwmmxt_tinsr (str)
4860      char * str;
4861 {
4862   unsigned long number;
4863
4864   if ((number = check_iwmmxt_insn (str, check_tinsr, 7)) == (unsigned long) FAIL)
4865     return;
4866
4867   inst.instruction |= number & 0x7;
4868   return;
4869 }
4870
4871 static void
4872 do_iwmmxt_tmcr (str)
4873      char * str;
4874 {
4875   check_iwmmxt_insn (str, check_tmcr, 0);
4876
4877   return;
4878 }
4879
4880 static void
4881 do_iwmmxt_tmcrr (str)
4882      char * str;
4883 {
4884   check_iwmmxt_insn (str, check_tmcrr, 0);
4885
4886   return;
4887 }
4888
4889 static void
4890 do_iwmmxt_tmia (str)
4891      char * str;
4892 {
4893   check_iwmmxt_insn (str, check_tmia, 0);
4894
4895   return;
4896 }
4897
4898 static void
4899 do_iwmmxt_tmovmsk (str)
4900      char * str;
4901 {
4902   check_iwmmxt_insn (str, check_tmovmsk, 0);
4903
4904   return;
4905 }
4906
4907 static void
4908 do_iwmmxt_tmrc (str)
4909      char * str;
4910 {
4911   check_iwmmxt_insn (str, check_tmrc, 0);
4912
4913   return;
4914 }
4915
4916 static void
4917 do_iwmmxt_tmrrc (str)
4918      char * str;
4919 {
4920   check_iwmmxt_insn (str, check_tmrrc, 0);
4921
4922   return;
4923 }
4924
4925 static void
4926 do_iwmmxt_torc (str)
4927      char * str;
4928 {
4929   check_iwmmxt_insn (str, check_rd, 0);
4930   return;
4931 }
4932
4933 static void
4934 do_iwmmxt_waligni (str)
4935      char * str;
4936 {
4937   unsigned long number;
4938
4939   if ((number = check_iwmmxt_insn (str, check_waligni, 7)) == (unsigned long) FAIL)
4940     return;
4941
4942   inst.instruction |= ((number & 0x7) << 20);
4943   return;
4944 }
4945
4946 static void
4947 do_iwmmxt_wmov (str)
4948      char * str;
4949 {
4950   if (check_iwmmxt_insn (str, check_wrwr, 0) == (unsigned long) FAIL)
4951     return;
4952
4953   inst.instruction |= ((inst.instruction >> 16) & 0xf);
4954   return;
4955 }
4956
4957 static void
4958 do_iwmmxt_word_addr (str)
4959      char * str;
4960 {
4961   int op = (inst.instruction & 0x300) >> 8;
4962   int reg;
4963
4964   inst.instruction &= ~0x300;
4965   inst.instruction |= (op & 1) << 22 | (op & 2) << 7;
4966
4967   skip_whitespace (str);
4968
4969   if ((reg = wreg_required_here (&str, 12, IWMMXT_REG_WR_OR_WC)) == FAIL
4970       || skip_past_comma (& str) == FAIL
4971       || cp_address_required_here (& str, CP_WB_OK) == FAIL)
4972     {
4973       if (! inst.error)
4974         inst.error = BAD_ARGS;
4975     }
4976   else
4977     end_of_line (str);
4978
4979   if (wc_register (reg))
4980     {
4981       inst.instruction |=  0xf0000100;
4982       inst.instruction &= ~0x00400000;
4983     }
4984 }
4985
4986 static void
4987 do_iwmmxt_wrwr (str)
4988      char * str;
4989 {
4990   check_iwmmxt_insn (str, check_wrwr, 0);
4991
4992   return;
4993 }
4994
4995 static void
4996 do_iwmmxt_wrwrwcg (str)
4997      char * str;
4998 {
4999   check_iwmmxt_insn (str, check_wrwrwcg, 0);
5000
5001   return;
5002 }
5003
5004 static void
5005 do_iwmmxt_wrwrwr (str)
5006      char * str;
5007 {
5008   check_iwmmxt_insn (str, check_wrwrwr, 0);
5009
5010   return;
5011 }
5012
5013 static void
5014 do_iwmmxt_wshufh (str)
5015      char * str;
5016 {
5017   unsigned long number;
5018
5019   if ((number = check_iwmmxt_insn (str, check_wshufh, 0xff)) == (unsigned long) FAIL)
5020     return;
5021
5022   inst.instruction |= ((number & 0xf0) << 16) | (number & 0xf);
5023   return;
5024 }
5025
5026 static void
5027 do_iwmmxt_wzero (str)
5028      char * str;
5029 {
5030   if (check_iwmmxt_insn (str, check_wr, 0) == (unsigned long) FAIL)
5031     return;
5032
5033   inst.instruction |= ((inst.instruction & 0xf) << 12) | ((inst.instruction & 0xf) << 16);
5034   return;
5035 }
5036
5037 /* Xscale multiply-accumulate (argument parse)
5038      MIAcc   acc0,Rm,Rs
5039      MIAPHcc acc0,Rm,Rs
5040      MIAxycc acc0,Rm,Rs.  */
5041
5042 static void
5043 do_xsc_mia (str)
5044      char * str;
5045 {
5046   int rs;
5047   int rm;
5048
5049   if (accum0_required_here (& str) == FAIL)
5050     inst.error = ERR_NO_ACCUM;
5051
5052   else if (skip_past_comma (& str) == FAIL
5053            || (rm = reg_required_here (& str, 0)) == FAIL)
5054     inst.error = BAD_ARGS;
5055
5056   else if (skip_past_comma (& str) == FAIL
5057            || (rs = reg_required_here (& str, 12)) == FAIL)
5058     inst.error = BAD_ARGS;
5059
5060   /* inst.instruction has now been zapped with both rm and rs.  */
5061   else if (rm == REG_PC || rs == REG_PC)
5062     inst.error = BAD_PC;        /* Undefined result if rm or rs is R15.  */
5063
5064   else
5065     end_of_line (str);
5066 }
5067
5068 /* Xscale move-accumulator-register (argument parse)
5069
5070      MARcc   acc0,RdLo,RdHi.  */
5071
5072 static void
5073 do_xsc_mar (str)
5074      char * str;
5075 {
5076   int rdlo, rdhi;
5077
5078   if (accum0_required_here (& str) == FAIL)
5079     inst.error = ERR_NO_ACCUM;
5080
5081   else if (skip_past_comma (& str) == FAIL
5082            || (rdlo = reg_required_here (& str, 12)) == FAIL)
5083     inst.error = BAD_ARGS;
5084
5085   else if (skip_past_comma (& str) == FAIL
5086            || (rdhi = reg_required_here (& str, 16)) == FAIL)
5087     inst.error = BAD_ARGS;
5088
5089   /* inst.instruction has now been zapped with both rdlo and rdhi.  */
5090   else if (rdlo == REG_PC || rdhi == REG_PC)
5091     inst.error = BAD_PC;        /* Undefined result if rdlo or rdhi is R15.  */
5092
5093   else
5094     end_of_line (str);
5095 }
5096
5097 /* Xscale move-register-accumulator (argument parse)
5098
5099      MRAcc   RdLo,RdHi,acc0.  */
5100
5101 static void
5102 do_xsc_mra (str)
5103      char * str;
5104 {
5105   int rdlo;
5106   int rdhi;
5107
5108   skip_whitespace (str);
5109
5110   if ((rdlo = reg_required_here (& str, 12)) == FAIL)
5111     inst.error = BAD_ARGS;
5112
5113   else if (skip_past_comma (& str) == FAIL
5114            || (rdhi = reg_required_here (& str, 16)) == FAIL)
5115     inst.error = BAD_ARGS;
5116
5117   else if  (skip_past_comma (& str) == FAIL
5118             || accum0_required_here (& str) == FAIL)
5119     inst.error = ERR_NO_ACCUM;
5120
5121   /* inst.instruction has now been zapped with both rdlo and rdhi.  */
5122   else if (rdlo == rdhi)
5123     inst.error = BAD_ARGS;      /* Undefined result if 2 writes to same reg.  */
5124
5125   else if (rdlo == REG_PC || rdhi == REG_PC)
5126     inst.error = BAD_PC;        /* Undefined result if rdlo or rdhi is R15.  */
5127   else
5128     end_of_line (str);
5129 }
5130
5131 /* ARMv5TE: Preload-Cache
5132
5133     PLD <addr_mode>
5134
5135   Syntactically, like LDR with B=1, W=0, L=1.  */
5136
5137 static void
5138 do_pld (str)
5139      char * str;
5140 {
5141   int rd;
5142
5143   skip_whitespace (str);
5144
5145   if (* str != '[')
5146     {
5147       inst.error = _("'[' expected after PLD mnemonic");
5148       return;
5149     }
5150
5151   ++str;
5152   skip_whitespace (str);
5153
5154   if ((rd = reg_required_here (& str, 16)) == FAIL)
5155     return;
5156
5157   skip_whitespace (str);
5158
5159   if (*str == ']')
5160     {
5161       /* [Rn], ... ?  */
5162       ++str;
5163       skip_whitespace (str);
5164
5165       /* Post-indexed addressing is not allowed with PLD.  */
5166       if (skip_past_comma (&str) == SUCCESS)
5167         {
5168           inst.error
5169             = _("post-indexed expression used in preload instruction");
5170           return;
5171         }
5172       else if (*str == '!') /* [Rn]! */
5173         {
5174           inst.error = _("writeback used in preload instruction");
5175           ++str;
5176         }
5177       else /* [Rn] */
5178         inst.instruction |= INDEX_UP | PRE_INDEX;
5179     }
5180   else /* [Rn, ...] */
5181     {
5182       if (skip_past_comma (& str) == FAIL)
5183         {
5184           inst.error = _("pre-indexed expression expected");
5185           return;
5186         }
5187
5188       if (ldst_extend (&str) == FAIL)
5189         return;
5190
5191       skip_whitespace (str);
5192
5193       if (* str != ']')
5194         {
5195           inst.error = _("missing ]");
5196           return;
5197         }
5198
5199       ++ str;
5200       skip_whitespace (str);
5201
5202       if (* str == '!') /* [Rn]! */
5203         {
5204           inst.error = _("writeback used in preload instruction");
5205           ++ str;
5206         }
5207
5208       inst.instruction |= PRE_INDEX;
5209     }
5210
5211   end_of_line (str);
5212 }
5213
5214 /* ARMv5TE load-consecutive (argument parse)
5215    Mode is like LDRH.
5216
5217      LDRccD R, mode
5218      STRccD R, mode.  */
5219
5220 static void
5221 do_ldrd (str)
5222      char * str;
5223 {
5224   int rd;
5225   int rn;
5226
5227   skip_whitespace (str);
5228
5229   if ((rd = reg_required_here (& str, 12)) == FAIL)
5230     {
5231       inst.error = BAD_ARGS;
5232       return;
5233     }
5234
5235   if (skip_past_comma (& str) == FAIL
5236       || (rn = ld_mode_required_here (& str)) == FAIL)
5237     {
5238       if (!inst.error)
5239         inst.error = BAD_ARGS;
5240       return;
5241     }
5242
5243   /* inst.instruction has now been zapped with Rd and the addressing mode.  */
5244   if (rd & 1)           /* Unpredictable result if Rd is odd.  */
5245     {
5246       inst.error = _("destination register must be even");
5247       return;
5248     }
5249
5250   if (rd == REG_LR)
5251     {
5252       inst.error = _("r14 not allowed here");
5253       return;
5254     }
5255
5256   if (((rd == rn) || (rd + 1 == rn))
5257       && ((inst.instruction & WRITE_BACK)
5258           || (!(inst.instruction & PRE_INDEX))))
5259     as_warn (_("pre/post-indexing used when modified address register is destination"));
5260
5261   /* For an index-register load, the index register must not overlap the
5262      destination (even if not write-back).  */
5263   if ((inst.instruction & V4_STR_BIT) == 0
5264       && (inst.instruction & HWOFFSET_IMM) == 0)
5265     {
5266       int rm = inst.instruction & 0x0000000f;
5267
5268       if (rm == rd || (rm == rd + 1))
5269         as_warn (_("ldrd destination registers must not overlap index register"));
5270     }
5271
5272   end_of_line (str);
5273 }
5274
5275 /* Returns the index into fp_values of a floating point number,
5276    or -1 if not in the table.  */
5277
5278 static int
5279 my_get_float_expression (str)
5280      char ** str;
5281 {
5282   LITTLENUM_TYPE words[MAX_LITTLENUMS];
5283   char *         save_in;
5284   expressionS    exp;
5285   int            i;
5286   int            j;
5287
5288   memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
5289
5290   /* Look for a raw floating point number.  */
5291   if ((save_in = atof_ieee (*str, 'x', words)) != NULL
5292       && is_end_of_line[(unsigned char) *save_in])
5293     {
5294       for (i = 0; i < NUM_FLOAT_VALS; i++)
5295         {
5296           for (j = 0; j < MAX_LITTLENUMS; j++)
5297             {
5298               if (words[j] != fp_values[i][j])
5299                 break;
5300             }
5301
5302           if (j == MAX_LITTLENUMS)
5303             {
5304               *str = save_in;
5305               return i;
5306             }
5307         }
5308     }
5309
5310   /* Try and parse a more complex expression, this will probably fail
5311      unless the code uses a floating point prefix (eg "0f").  */
5312   save_in = input_line_pointer;
5313   input_line_pointer = *str;
5314   if (expression (&exp) == absolute_section
5315       && exp.X_op == O_big
5316       && exp.X_add_number < 0)
5317     {
5318       /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
5319          Ditto for 15.  */
5320       if (gen_to_words (words, 5, (long) 15) == 0)
5321         {
5322           for (i = 0; i < NUM_FLOAT_VALS; i++)
5323             {
5324               for (j = 0; j < MAX_LITTLENUMS; j++)
5325                 {
5326                   if (words[j] != fp_values[i][j])
5327                     break;
5328                 }
5329
5330               if (j == MAX_LITTLENUMS)
5331                 {
5332                   *str = input_line_pointer;
5333                   input_line_pointer = save_in;
5334                   return i;
5335                 }
5336             }
5337         }
5338     }
5339
5340   *str = input_line_pointer;
5341   input_line_pointer = save_in;
5342   return -1;
5343 }
5344
5345 /* Return TRUE if anything in the expression is a bignum.  */
5346
5347 static int
5348 walk_no_bignums (sp)
5349      symbolS * sp;
5350 {
5351   if (symbol_get_value_expression (sp)->X_op == O_big)
5352     return 1;
5353
5354   if (symbol_get_value_expression (sp)->X_add_symbol)
5355     {
5356       return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
5357               || (symbol_get_value_expression (sp)->X_op_symbol
5358                   && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
5359     }
5360
5361   return 0;
5362 }
5363
5364 static int in_my_get_expression = 0;
5365
5366 static int
5367 my_get_expression (ep, str)
5368      expressionS * ep;
5369      char ** str;
5370 {
5371   char * save_in;
5372   segT   seg;
5373
5374   save_in = input_line_pointer;
5375   input_line_pointer = *str;
5376   in_my_get_expression = 1;
5377   seg = expression (ep);
5378   in_my_get_expression = 0;
5379
5380   if (ep->X_op == O_illegal)
5381     {
5382       /* We found a bad expression in md_operand().  */
5383       *str = input_line_pointer;
5384       input_line_pointer = save_in;
5385       return 1;
5386     }
5387
5388 #ifdef OBJ_AOUT
5389   if (seg != absolute_section
5390       && seg != text_section
5391       && seg != data_section
5392       && seg != bss_section
5393       && seg != undefined_section)
5394     {
5395       inst.error = _("bad_segment");
5396       *str = input_line_pointer;
5397       input_line_pointer = save_in;
5398       return 1;
5399     }
5400 #endif
5401
5402   /* Get rid of any bignums now, so that we don't generate an error for which
5403      we can't establish a line number later on.  Big numbers are never valid
5404      in instructions, which is where this routine is always called.  */
5405   if (ep->X_op == O_big
5406       || (ep->X_add_symbol
5407           && (walk_no_bignums (ep->X_add_symbol)
5408               || (ep->X_op_symbol
5409                   && walk_no_bignums (ep->X_op_symbol)))))
5410     {
5411       inst.error = _("invalid constant");
5412       *str = input_line_pointer;
5413       input_line_pointer = save_in;
5414       return 1;
5415     }
5416
5417   *str = input_line_pointer;
5418   input_line_pointer = save_in;
5419   return 0;
5420 }
5421
5422 /* We handle all bad expressions here, so that we can report the faulty
5423    instruction in the error message.  */
5424 void
5425 md_operand (expr)
5426      expressionS *expr;
5427 {
5428   if (in_my_get_expression)
5429     {
5430       expr->X_op = O_illegal;
5431       if (inst.error == NULL)
5432         inst.error = _("bad expression");
5433     }
5434 }
5435
5436 /* UNRESTRICT should be one if <shift> <register> is permitted for this
5437    instruction.  */
5438
5439 static int
5440 decode_shift (str, unrestrict)
5441      char ** str;
5442      int     unrestrict;
5443 {
5444   const struct asm_shift_name * shift;
5445   char * p;
5446   char   c;
5447
5448   skip_whitespace (* str);
5449
5450   for (p = * str; ISALPHA (* p); p ++)
5451     ;
5452
5453   if (p == * str)
5454     {
5455       inst.error = _("shift expression expected");
5456       return FAIL;
5457     }
5458
5459   c = * p;
5460   * p = '\0';
5461   shift = (const struct asm_shift_name *) hash_find (arm_shift_hsh, * str);
5462   * p = c;
5463
5464   if (shift == NULL)
5465     {
5466       inst.error = _("shift expression expected");
5467       return FAIL;
5468     }
5469
5470   assert (shift->properties->index == shift_properties[shift->properties->index].index);
5471
5472   if (shift->properties->index == SHIFT_RRX)
5473     {
5474       * str = p;
5475       inst.instruction |= shift->properties->bit_field;
5476       return SUCCESS;
5477     }
5478
5479   skip_whitespace (p);
5480
5481   if (unrestrict && reg_required_here (& p, 8) != FAIL)
5482     {
5483       inst.instruction |= shift->properties->bit_field | SHIFT_BY_REG;
5484       * str = p;
5485       return SUCCESS;
5486     }
5487   else if (! is_immediate_prefix (* p))
5488     {
5489       inst.error = (unrestrict
5490                     ? _("shift requires register or #expression")
5491                     : _("shift requires #expression"));
5492       * str = p;
5493       return FAIL;
5494     }
5495
5496   inst.error = NULL;
5497   p ++;
5498
5499   if (my_get_expression (& inst.reloc.exp, & p))
5500     return FAIL;
5501
5502   /* Validate some simple #expressions.  */
5503   if (inst.reloc.exp.X_op == O_constant)
5504     {
5505       unsigned num = inst.reloc.exp.X_add_number;
5506
5507       /* Reject operations greater than 32.  */
5508       if (num > 32
5509           /* Reject a shift of 0 unless the mode allows it.  */
5510           || (num == 0 && shift->properties->allows_0 == 0)
5511           /* Reject a shift of 32 unless the mode allows it.  */
5512           || (num == 32 && shift->properties->allows_32 == 0)
5513           )
5514         {
5515           /* As a special case we allow a shift of zero for
5516              modes that do not support it to be recoded as an
5517              logical shift left of zero (ie nothing).  We warn
5518              about this though.  */
5519           if (num == 0)
5520             {
5521               as_warn (_("shift of 0 ignored."));
5522               shift = & shift_names[0];
5523               assert (shift->properties->index == SHIFT_LSL);
5524             }
5525           else
5526             {
5527               inst.error = _("invalid immediate shift");
5528               return FAIL;
5529             }
5530         }
5531
5532       /* Shifts of 32 are encoded as 0, for those shifts that
5533          support it.  */
5534       if (num == 32)
5535         num = 0;
5536
5537       inst.instruction |= (num << 7) | shift->properties->bit_field;
5538     }
5539   else
5540     {
5541       inst.reloc.type   = BFD_RELOC_ARM_SHIFT_IMM;
5542       inst.reloc.pc_rel = 0;
5543       inst.instruction |= shift->properties->bit_field;
5544     }
5545
5546   * str = p;
5547   return SUCCESS;
5548 }
5549
5550 /* Do those data_ops which can take a negative immediate constant
5551    by altering the instuction.  A bit of a hack really.
5552         MOV <-> MVN
5553         AND <-> BIC
5554         ADC <-> SBC
5555         by inverting the second operand, and
5556         ADD <-> SUB
5557         CMP <-> CMN
5558         by negating the second operand.  */
5559
5560 static int
5561 negate_data_op (instruction, value)
5562      unsigned long * instruction;
5563      unsigned long   value;
5564 {
5565   int op, new_inst;
5566   unsigned long negated, inverted;
5567
5568   negated = validate_immediate (-value);
5569   inverted = validate_immediate (~value);
5570
5571   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
5572   switch (op)
5573     {
5574       /* First negates.  */
5575     case OPCODE_SUB:             /* ADD <-> SUB  */
5576       new_inst = OPCODE_ADD;
5577       value = negated;
5578       break;
5579
5580     case OPCODE_ADD:
5581       new_inst = OPCODE_SUB;
5582       value = negated;
5583       break;
5584
5585     case OPCODE_CMP:             /* CMP <-> CMN  */
5586       new_inst = OPCODE_CMN;
5587       value = negated;
5588       break;
5589
5590     case OPCODE_CMN:
5591       new_inst = OPCODE_CMP;
5592       value = negated;
5593       break;
5594
5595       /* Now Inverted ops.  */
5596     case OPCODE_MOV:             /* MOV <-> MVN  */
5597       new_inst = OPCODE_MVN;
5598       value = inverted;
5599       break;
5600
5601     case OPCODE_MVN:
5602       new_inst = OPCODE_MOV;
5603       value = inverted;
5604       break;
5605
5606     case OPCODE_AND:             /* AND <-> BIC  */
5607       new_inst = OPCODE_BIC;
5608       value = inverted;
5609       break;
5610
5611     case OPCODE_BIC:
5612       new_inst = OPCODE_AND;
5613       value = inverted;
5614       break;
5615
5616     case OPCODE_ADC:              /* ADC <-> SBC  */
5617       new_inst = OPCODE_SBC;
5618       value = inverted;
5619       break;
5620
5621     case OPCODE_SBC:
5622       new_inst = OPCODE_ADC;
5623       value = inverted;
5624       break;
5625
5626       /* We cannot do anything.  */
5627     default:
5628       return FAIL;
5629     }
5630
5631   if (value == (unsigned) FAIL)
5632     return FAIL;
5633
5634   *instruction &= OPCODE_MASK;
5635   *instruction |= new_inst << DATA_OP_SHIFT;
5636   return value;
5637 }
5638
5639 static int
5640 data_op2 (str)
5641      char ** str;
5642 {
5643   int value;
5644   expressionS expr;
5645
5646   skip_whitespace (* str);
5647
5648   if (reg_required_here (str, 0) != FAIL)
5649     {
5650       if (skip_past_comma (str) == SUCCESS)
5651         /* Shift operation on register.  */
5652         return decode_shift (str, NO_SHIFT_RESTRICT);
5653
5654       return SUCCESS;
5655     }
5656   else
5657     {
5658       /* Immediate expression.  */
5659       if (is_immediate_prefix (**str))
5660         {
5661           (*str)++;
5662           inst.error = NULL;
5663
5664           if (my_get_expression (&inst.reloc.exp, str))
5665             return FAIL;
5666
5667           if (inst.reloc.exp.X_add_symbol)
5668             {
5669               inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
5670               inst.reloc.pc_rel = 0;
5671             }
5672           else
5673             {
5674               if (skip_past_comma (str) == SUCCESS)
5675                 {
5676                   /* #x, y -- ie explicit rotation by Y.  */
5677                   if (my_get_expression (&expr, str))
5678                     return FAIL;
5679
5680                   if (expr.X_op != O_constant)
5681                     {
5682                       inst.error = _("constant expression expected");
5683                       return FAIL;
5684                     }
5685
5686                   /* Rotate must be a multiple of 2.  */
5687                   if (((unsigned) expr.X_add_number) > 30
5688                       || (expr.X_add_number & 1) != 0
5689                       || ((unsigned) inst.reloc.exp.X_add_number) > 255)
5690                     {
5691                       inst.error = _("invalid constant");
5692                       return FAIL;
5693                     }
5694                   inst.instruction |= INST_IMMEDIATE;
5695                   inst.instruction |= inst.reloc.exp.X_add_number;
5696                   inst.instruction |= expr.X_add_number << 7;
5697                   return SUCCESS;
5698                 }
5699
5700               /* Implicit rotation, select a suitable one.  */
5701               value = validate_immediate (inst.reloc.exp.X_add_number);
5702
5703               if (value == FAIL)
5704                 {
5705                   /* Can't be done.  Perhaps the code reads something like
5706                      "add Rd, Rn, #-n", where "sub Rd, Rn, #n" would be OK.  */
5707                   if ((value = negate_data_op (&inst.instruction,
5708                                                inst.reloc.exp.X_add_number))
5709                       == FAIL)
5710                     {
5711                       inst.error = _("invalid constant");
5712                       return FAIL;
5713                     }
5714                 }
5715
5716               inst.instruction |= value;
5717             }
5718
5719           inst.instruction |= INST_IMMEDIATE;
5720           return SUCCESS;
5721         }
5722
5723       (*str)++;
5724       inst.error = _("register or shift expression expected");
5725       return FAIL;
5726     }
5727 }
5728
5729 static int
5730 fp_op2 (str)
5731      char ** str;
5732 {
5733   skip_whitespace (* str);
5734
5735   if (fp_reg_required_here (str, 0) != FAIL)
5736     return SUCCESS;
5737   else
5738     {
5739       /* Immediate expression.  */
5740       if (*((*str)++) == '#')
5741         {
5742           int i;
5743
5744           inst.error = NULL;
5745
5746           skip_whitespace (* str);
5747
5748           /* First try and match exact strings, this is to guarantee
5749              that some formats will work even for cross assembly.  */
5750
5751           for (i = 0; fp_const[i]; i++)
5752             {
5753               if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
5754                 {
5755                   char *start = *str;
5756
5757                   *str += strlen (fp_const[i]);
5758                   if (is_end_of_line[(unsigned char) **str])
5759                     {
5760                       inst.instruction |= i + 8;
5761                       return SUCCESS;
5762                     }
5763                   *str = start;
5764                 }
5765             }
5766
5767           /* Just because we didn't get a match doesn't mean that the
5768              constant isn't valid, just that it is in a format that we
5769              don't automatically recognize.  Try parsing it with
5770              the standard expression routines.  */
5771           if ((i = my_get_float_expression (str)) >= 0)
5772             {
5773               inst.instruction |= i + 8;
5774               return SUCCESS;
5775             }
5776
5777           inst.error = _("invalid floating point immediate expression");
5778           return FAIL;
5779         }
5780       inst.error =
5781         _("floating point register or immediate expression expected");
5782       return FAIL;
5783     }
5784 }
5785
5786 static void
5787 do_arit (str)
5788      char * str;
5789 {
5790   skip_whitespace (str);
5791
5792   if (reg_required_here (&str, 12) == FAIL
5793       || skip_past_comma (&str) == FAIL
5794       || reg_required_here (&str, 16) == FAIL
5795       || skip_past_comma (&str) == FAIL
5796       || data_op2 (&str) == FAIL)
5797     {
5798       if (!inst.error)
5799         inst.error = BAD_ARGS;
5800       return;
5801     }
5802
5803   end_of_line (str);
5804   return;
5805 }
5806
5807 static void
5808 do_adr (str)
5809      char * str;
5810 {
5811   /* This is a pseudo-op of the form "adr rd, label" to be converted
5812      into a relative address of the form "add rd, pc, #label-.-8".  */
5813   skip_whitespace (str);
5814
5815   if (reg_required_here (&str, 12) == FAIL
5816       || skip_past_comma (&str) == FAIL
5817       || my_get_expression (&inst.reloc.exp, &str))
5818     {
5819       if (!inst.error)
5820         inst.error = BAD_ARGS;
5821       return;
5822     }
5823
5824   /* Frag hacking will turn this into a sub instruction if the offset turns
5825      out to be negative.  */
5826   inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
5827   inst.reloc.exp.X_add_number -= 8; /* PC relative adjust.  */
5828   inst.reloc.pc_rel = 1;
5829
5830   end_of_line (str);
5831 }
5832
5833 static void
5834 do_adrl (str)
5835      char * str;
5836 {
5837   /* This is a pseudo-op of the form "adrl rd, label" to be converted
5838      into a relative address of the form:
5839      add rd, pc, #low(label-.-8)"
5840      add rd, rd, #high(label-.-8)"  */
5841
5842   skip_whitespace (str);
5843
5844   if (reg_required_here (&str, 12) == FAIL
5845       || skip_past_comma (&str) == FAIL
5846       || my_get_expression (&inst.reloc.exp, &str))
5847     {
5848       if (!inst.error)
5849         inst.error = BAD_ARGS;
5850
5851       return;
5852     }
5853
5854   end_of_line (str);
5855   /* Frag hacking will turn this into a sub instruction if the offset turns
5856      out to be negative.  */
5857   inst.reloc.type              = BFD_RELOC_ARM_ADRL_IMMEDIATE;
5858   inst.reloc.exp.X_add_number -= 8; /* PC relative adjust  */
5859   inst.reloc.pc_rel            = 1;
5860   inst.size                    = INSN_SIZE * 2;
5861
5862   return;
5863 }
5864
5865 static void
5866 do_cmp (str)
5867      char * str;
5868 {
5869   skip_whitespace (str);
5870
5871   if (reg_required_here (&str, 16) == FAIL)
5872     {
5873       if (!inst.error)
5874         inst.error = BAD_ARGS;
5875       return;
5876     }
5877
5878   if (skip_past_comma (&str) == FAIL
5879       || data_op2 (&str) == FAIL)
5880     {
5881       if (!inst.error)
5882         inst.error = BAD_ARGS;
5883       return;
5884     }
5885
5886   end_of_line (str);
5887   return;
5888 }
5889
5890 static void
5891 do_mov (str)
5892      char * str;
5893 {
5894   skip_whitespace (str);
5895
5896   if (reg_required_here (&str, 12) == FAIL)
5897     {
5898       if (!inst.error)
5899         inst.error = BAD_ARGS;
5900       return;
5901     }
5902
5903   if (skip_past_comma (&str) == FAIL
5904       || data_op2 (&str) == FAIL)
5905     {
5906       if (!inst.error)
5907         inst.error = BAD_ARGS;
5908       return;
5909     }
5910
5911   end_of_line (str);
5912   return;
5913 }
5914
5915 static int
5916 ldst_extend (str)
5917      char ** str;
5918 {
5919   int add = INDEX_UP;
5920
5921   switch (**str)
5922     {
5923     case '#':
5924     case '$':
5925       (*str)++;
5926       if (my_get_expression (& inst.reloc.exp, str))
5927         return FAIL;
5928
5929       if (inst.reloc.exp.X_op == O_constant)
5930         {
5931           int value = inst.reloc.exp.X_add_number;
5932
5933           if (value < -4095 || value > 4095)
5934             {
5935               inst.error = _("address offset too large");
5936               return FAIL;
5937             }
5938
5939           if (value < 0)
5940             {
5941               value = -value;
5942               add = 0;
5943             }
5944
5945           inst.instruction |= add | value;
5946         }
5947       else
5948         {
5949           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
5950           inst.reloc.pc_rel = 0;
5951         }
5952       return SUCCESS;
5953
5954     case '-':
5955       add = 0;
5956       /* Fall through.  */
5957
5958     case '+':
5959       (*str)++;
5960       /* Fall through.  */
5961
5962     default:
5963       if (reg_required_here (str, 0) == FAIL)
5964         return FAIL;
5965
5966       inst.instruction |= add | OFFSET_REG;
5967       if (skip_past_comma (str) == SUCCESS)
5968         return decode_shift (str, SHIFT_RESTRICT);
5969
5970       return SUCCESS;
5971     }
5972 }
5973
5974 static void
5975 do_ldst (str)
5976      char *        str;
5977 {
5978   int pre_inc = 0;
5979   int conflict_reg;
5980   int value;
5981
5982   skip_whitespace (str);
5983
5984   if ((conflict_reg = reg_required_here (&str, 12)) == FAIL)
5985     {
5986       if (!inst.error)
5987         inst.error = BAD_ARGS;
5988       return;
5989     }
5990
5991   if (skip_past_comma (&str) == FAIL)
5992     {
5993       inst.error = _("address expected");
5994       return;
5995     }
5996
5997   if (*str == '[')
5998     {
5999       int reg;
6000
6001       str++;
6002
6003       skip_whitespace (str);
6004
6005       if ((reg = reg_required_here (&str, 16)) == FAIL)
6006         return;
6007
6008       /* Conflicts can occur on stores as well as loads.  */
6009       conflict_reg = (conflict_reg == reg);
6010
6011       skip_whitespace (str);
6012
6013       if (*str == ']')
6014         {
6015           str ++;
6016
6017           if (skip_past_comma (&str) == SUCCESS)
6018             {
6019               /* [Rn],... (post inc)  */
6020               if (ldst_extend (&str) == FAIL)
6021                 return;
6022               if (conflict_reg)
6023                 as_warn (_("%s register same as write-back base"),
6024                          ((inst.instruction & LOAD_BIT)
6025                           ? _("destination") : _("source")));
6026             }
6027           else
6028             {
6029               /* [Rn]  */
6030               skip_whitespace (str);
6031
6032               if (*str == '!')
6033                 {
6034                   if (conflict_reg)
6035                     as_warn (_("%s register same as write-back base"),
6036                              ((inst.instruction & LOAD_BIT)
6037                               ? _("destination") : _("source")));
6038                   str++;
6039                   inst.instruction |= WRITE_BACK;
6040                 }
6041
6042               inst.instruction |= INDEX_UP;
6043               pre_inc = 1;
6044             }
6045         }
6046       else
6047         {
6048           /* [Rn,...]  */
6049           if (skip_past_comma (&str) == FAIL)
6050             {
6051               inst.error = _("pre-indexed expression expected");
6052               return;
6053             }
6054
6055           pre_inc = 1;
6056           if (ldst_extend (&str) == FAIL)
6057             return;
6058
6059           skip_whitespace (str);
6060
6061           if (*str++ != ']')
6062             {
6063               inst.error = _("missing ]");
6064               return;
6065             }
6066
6067           skip_whitespace (str);
6068
6069           if (*str == '!')
6070             {
6071               if (conflict_reg)
6072                 as_warn (_("%s register same as write-back base"),
6073                          ((inst.instruction & LOAD_BIT)
6074                           ? _("destination") : _("source")));
6075               str++;
6076               inst.instruction |= WRITE_BACK;
6077             }
6078         }
6079     }
6080   else if (*str == '=')
6081     {
6082       if ((inst.instruction & LOAD_BIT) == 0)
6083         {
6084           inst.error = _("invalid pseudo operation");
6085           return;
6086         }
6087
6088       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
6089       str++;
6090
6091       skip_whitespace (str);
6092
6093       if (my_get_expression (&inst.reloc.exp, &str))
6094         return;
6095
6096       if (inst.reloc.exp.X_op != O_constant
6097           && inst.reloc.exp.X_op != O_symbol)
6098         {
6099           inst.error = _("constant expression expected");
6100           return;
6101         }
6102
6103       if (inst.reloc.exp.X_op == O_constant)
6104         {
6105           value = validate_immediate (inst.reloc.exp.X_add_number);
6106
6107           if (value != FAIL)
6108             {
6109               /* This can be done with a mov instruction.  */
6110               inst.instruction &= LITERAL_MASK;
6111               inst.instruction |= (INST_IMMEDIATE
6112                                    | (OPCODE_MOV << DATA_OP_SHIFT));
6113               inst.instruction |= value & 0xfff;
6114               end_of_line (str);
6115               return;
6116             }
6117
6118           value = validate_immediate (~inst.reloc.exp.X_add_number);
6119
6120           if (value != FAIL)
6121             {
6122               /* This can be done with a mvn instruction.  */
6123               inst.instruction &= LITERAL_MASK;
6124               inst.instruction |= (INST_IMMEDIATE
6125                                    | (OPCODE_MVN << DATA_OP_SHIFT));
6126               inst.instruction |= value & 0xfff;
6127               end_of_line (str);
6128               return;
6129             }
6130         }
6131
6132       /* Insert into literal pool.  */
6133       if (add_to_lit_pool () == FAIL)
6134         {
6135           if (!inst.error)
6136             inst.error = _("literal pool insertion failed");
6137           return;
6138         }
6139
6140       /* Change the instruction exp to point to the pool.  */
6141       inst.reloc.type = BFD_RELOC_ARM_LITERAL;
6142       inst.reloc.pc_rel = 1;
6143       inst.instruction |= (REG_PC << 16);
6144       pre_inc = 1;
6145     }
6146   else
6147     {
6148       if (my_get_expression (&inst.reloc.exp, &str))
6149         return;
6150
6151       inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
6152 #ifndef TE_WINCE
6153       /* PC rel adjust.  */
6154       inst.reloc.exp.X_add_number -= 8;
6155 #endif
6156       inst.reloc.pc_rel = 1;
6157       inst.instruction |= (REG_PC << 16);
6158       pre_inc = 1;
6159     }
6160
6161   inst.instruction |= (pre_inc ? PRE_INDEX : 0);
6162   end_of_line (str);
6163   return;
6164 }
6165
6166 static void
6167 do_ldstt (str)
6168      char *        str;
6169 {
6170   int conflict_reg;
6171
6172   skip_whitespace (str);
6173
6174   if ((conflict_reg = reg_required_here (& str, 12)) == FAIL)
6175     {
6176       if (!inst.error)
6177         inst.error = BAD_ARGS;
6178       return;
6179     }
6180
6181   if (skip_past_comma (& str) == FAIL)
6182     {
6183       inst.error = _("address expected");
6184       return;
6185     }
6186
6187   if (*str == '[')
6188     {
6189       int reg;
6190
6191       str++;
6192
6193       skip_whitespace (str);
6194
6195       if ((reg = reg_required_here (&str, 16)) == FAIL)
6196         return;
6197
6198       /* ldrt/strt always use post-indexed addressing, so if the base is
6199          the same as Rd, we warn.  */
6200       if (conflict_reg == reg)
6201         as_warn (_("%s register same as write-back base"),
6202                  ((inst.instruction & LOAD_BIT)
6203                   ? _("destination") : _("source")));
6204
6205       skip_whitespace (str);
6206
6207       if (*str == ']')
6208         {
6209           str ++;
6210
6211           if (skip_past_comma (&str) == SUCCESS)
6212             {
6213               /* [Rn],... (post inc)  */
6214               if (ldst_extend (&str) == FAIL)
6215                 return;
6216             }
6217           else
6218             {
6219               /* [Rn]  */
6220               skip_whitespace (str);
6221
6222               /* Skip a write-back '!'.  */
6223               if (*str == '!')
6224                 str++;
6225
6226               inst.instruction |= INDEX_UP;
6227             }
6228         }
6229       else
6230         {
6231           inst.error = _("post-indexed expression expected");
6232           return;
6233         }
6234     }
6235   else
6236     {
6237       inst.error = _("post-indexed expression expected");
6238       return;
6239     }
6240
6241   end_of_line (str);
6242   return;
6243 }
6244
6245 static int
6246 ldst_extend_v4 (str)
6247      char ** str;
6248 {
6249   int add = INDEX_UP;
6250
6251   switch (**str)
6252     {
6253     case '#':
6254     case '$':
6255       (*str)++;
6256       if (my_get_expression (& inst.reloc.exp, str))
6257         return FAIL;
6258
6259       if (inst.reloc.exp.X_op == O_constant)
6260         {
6261           int value = inst.reloc.exp.X_add_number;
6262
6263           if (value < -255 || value > 255)
6264             {
6265               inst.error = _("address offset too large");
6266               return FAIL;
6267             }
6268
6269           if (value < 0)
6270             {
6271               value = -value;
6272               add = 0;
6273             }
6274
6275           /* Halfword and signextension instructions have the
6276              immediate value split across bits 11..8 and bits 3..0.  */
6277           inst.instruction |= (add | HWOFFSET_IMM
6278                                | ((value >> 4) << 8) | (value & 0xF));
6279         }
6280       else
6281         {
6282           inst.instruction |= HWOFFSET_IMM;
6283           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
6284           inst.reloc.pc_rel = 0;
6285         }
6286       return SUCCESS;
6287
6288     case '-':
6289       add = 0;
6290       /* Fall through.  */
6291
6292     case '+':
6293       (*str)++;
6294       /* Fall through.  */
6295
6296     default:
6297       if (reg_required_here (str, 0) == FAIL)
6298         return FAIL;
6299
6300       inst.instruction |= add;
6301       return SUCCESS;
6302     }
6303 }
6304
6305 /* Halfword and signed-byte load/store operations.  */
6306 static void
6307 do_ldstv4 (str)
6308      char *        str;
6309 {
6310   int pre_inc = 0;
6311   int conflict_reg;
6312   int value;
6313
6314   skip_whitespace (str);
6315
6316   if ((conflict_reg = reg_required_here (& str, 12)) == FAIL)
6317     {
6318       if (!inst.error)
6319         inst.error = BAD_ARGS;
6320       return;
6321     }
6322
6323   if (skip_past_comma (& str) == FAIL)
6324     {
6325       inst.error = _("address expected");
6326       return;
6327     }
6328
6329   if (*str == '[')
6330     {
6331       int reg;
6332
6333       str++;
6334
6335       skip_whitespace (str);
6336
6337       if ((reg = reg_required_here (&str, 16)) == FAIL)
6338         return;
6339
6340       /* Conflicts can occur on stores as well as loads.  */
6341       conflict_reg = (conflict_reg == reg);
6342
6343       skip_whitespace (str);
6344
6345       if (*str == ']')
6346         {
6347           str ++;
6348
6349           if (skip_past_comma (&str) == SUCCESS)
6350             {
6351               /* [Rn],... (post inc)  */
6352               if (ldst_extend_v4 (&str) == FAIL)
6353                 return;
6354               if (conflict_reg)
6355                 as_warn (_("%s register same as write-back base"),
6356                          ((inst.instruction & LOAD_BIT)
6357                           ? _("destination") : _("source")));
6358             }
6359           else
6360             {
6361               /* [Rn]  */
6362               inst.instruction |= HWOFFSET_IMM;
6363
6364               skip_whitespace (str);
6365
6366               if (*str == '!')
6367                 {
6368                   if (conflict_reg)
6369                     as_warn (_("%s register same as write-back base"),
6370                              ((inst.instruction & LOAD_BIT)
6371                               ? _("destination") : _("source")));
6372                   str++;
6373                   inst.instruction |= WRITE_BACK;
6374                 }
6375
6376               inst.instruction |= INDEX_UP;
6377               pre_inc = 1;
6378             }
6379         }
6380       else
6381         {
6382           /* [Rn,...]  */
6383           if (skip_past_comma (&str) == FAIL)
6384             {
6385               inst.error = _("pre-indexed expression expected");
6386               return;
6387             }
6388
6389           pre_inc = 1;
6390           if (ldst_extend_v4 (&str) == FAIL)
6391             return;
6392
6393           skip_whitespace (str);
6394
6395           if (*str++ != ']')
6396             {
6397               inst.error = _("missing ]");
6398               return;
6399             }
6400
6401           skip_whitespace (str);
6402
6403           if (*str == '!')
6404             {
6405               if (conflict_reg)
6406                 as_warn (_("%s register same as write-back base"),
6407                          ((inst.instruction & LOAD_BIT)
6408                           ? _("destination") : _("source")));
6409               str++;
6410               inst.instruction |= WRITE_BACK;
6411             }
6412         }
6413     }
6414   else if (*str == '=')
6415     {
6416       if ((inst.instruction & LOAD_BIT) == 0)
6417         {
6418           inst.error = _("invalid pseudo operation");
6419           return;
6420         }
6421
6422       /* XXX Does this work correctly for half-word/byte ops?  */
6423       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
6424       str++;
6425
6426       skip_whitespace (str);
6427
6428       if (my_get_expression (&inst.reloc.exp, &str))
6429         return;
6430
6431       if (inst.reloc.exp.X_op != O_constant
6432           && inst.reloc.exp.X_op != O_symbol)
6433         {
6434           inst.error = _("constant expression expected");
6435           return;
6436         }
6437
6438       if (inst.reloc.exp.X_op == O_constant)
6439         {
6440           value = validate_immediate (inst.reloc.exp.X_add_number);
6441
6442           if (value != FAIL)
6443             {
6444               /* This can be done with a mov instruction.  */
6445               inst.instruction &= LITERAL_MASK;
6446               inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
6447               inst.instruction |= value & 0xfff;
6448               end_of_line (str);
6449               return;
6450             }
6451
6452           value = validate_immediate (~ inst.reloc.exp.X_add_number);
6453
6454           if (value != FAIL)
6455             {
6456               /* This can be done with a mvn instruction.  */
6457               inst.instruction &= LITERAL_MASK;
6458               inst.instruction |= INST_IMMEDIATE | (OPCODE_MVN << DATA_OP_SHIFT);
6459               inst.instruction |= value & 0xfff;
6460               end_of_line (str);
6461               return;
6462             }
6463         }
6464
6465       /* Insert into literal pool.  */
6466       if (add_to_lit_pool () == FAIL)
6467         {
6468           if (!inst.error)
6469             inst.error = _("literal pool insertion failed");
6470           return;
6471         }
6472
6473       /* Change the instruction exp to point to the pool.  */
6474       inst.instruction |= HWOFFSET_IMM;
6475       inst.reloc.type = BFD_RELOC_ARM_HWLITERAL;
6476       inst.reloc.pc_rel = 1;
6477       inst.instruction |= (REG_PC << 16);
6478       pre_inc = 1;
6479     }
6480   else
6481     {
6482       if (my_get_expression (&inst.reloc.exp, &str))
6483         return;
6484
6485       inst.instruction |= HWOFFSET_IMM;
6486       inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
6487 #ifndef TE_WINCE
6488       /* PC rel adjust.  */
6489       inst.reloc.exp.X_add_number -= 8;
6490 #endif
6491       inst.reloc.pc_rel = 1;
6492       inst.instruction |= (REG_PC << 16);
6493       pre_inc = 1;
6494     }
6495
6496   inst.instruction |= (pre_inc ? PRE_INDEX : 0);
6497   end_of_line (str);
6498   return;
6499 }
6500
6501 static long
6502 reg_list (strp)
6503      char ** strp;
6504 {
6505   char * str = * strp;
6506   long   range = 0;
6507   int    another_range;
6508
6509   /* We come back here if we get ranges concatenated by '+' or '|'.  */
6510   do
6511     {
6512       another_range = 0;
6513
6514       if (*str == '{')
6515         {
6516           int in_range = 0;
6517           int cur_reg = -1;
6518
6519           str++;
6520           do
6521             {
6522               int reg;
6523
6524               skip_whitespace (str);
6525
6526               if ((reg = reg_required_here (& str, -1)) == FAIL)
6527                 return FAIL;
6528
6529               if (in_range)
6530                 {
6531                   int i;
6532
6533                   if (reg <= cur_reg)
6534                     {
6535                       inst.error = _("bad range in register list");
6536                       return FAIL;
6537                     }
6538
6539                   for (i = cur_reg + 1; i < reg; i++)
6540                     {
6541                       if (range & (1 << i))
6542                         as_tsktsk
6543                           (_("Warning: duplicated register (r%d) in register list"),
6544                            i);
6545                       else
6546                         range |= 1 << i;
6547                     }
6548                   in_range = 0;
6549                 }
6550
6551               if (range & (1 << reg))
6552                 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
6553                            reg);
6554               else if (reg <= cur_reg)
6555                 as_tsktsk (_("Warning: register range not in ascending order"));
6556
6557               range |= 1 << reg;
6558               cur_reg = reg;
6559             }
6560           while (skip_past_comma (&str) != FAIL
6561                  || (in_range = 1, *str++ == '-'));
6562           str--;
6563           skip_whitespace (str);
6564
6565           if (*str++ != '}')
6566             {
6567               inst.error = _("missing `}'");
6568               return FAIL;
6569             }
6570         }
6571       else
6572         {
6573           expressionS expr;
6574
6575           if (my_get_expression (&expr, &str))
6576             return FAIL;
6577
6578           if (expr.X_op == O_constant)
6579             {
6580               if (expr.X_add_number
6581                   != (expr.X_add_number & 0x0000ffff))
6582                 {
6583                   inst.error = _("invalid register mask");
6584                   return FAIL;
6585                 }
6586
6587               if ((range & expr.X_add_number) != 0)
6588                 {
6589                   int regno = range & expr.X_add_number;
6590
6591                   regno &= -regno;
6592                   regno = (1 << regno) - 1;
6593                   as_tsktsk
6594                     (_("Warning: duplicated register (r%d) in register list"),
6595                      regno);
6596                 }
6597
6598               range |= expr.X_add_number;
6599             }
6600           else
6601             {
6602               if (inst.reloc.type != 0)
6603                 {
6604                   inst.error = _("expression too complex");
6605                   return FAIL;
6606                 }
6607
6608               memcpy (&inst.reloc.exp, &expr, sizeof (expressionS));
6609               inst.reloc.type = BFD_RELOC_ARM_MULTI;
6610               inst.reloc.pc_rel = 0;
6611             }
6612         }
6613
6614       skip_whitespace (str);
6615
6616       if (*str == '|' || *str == '+')
6617         {
6618           str++;
6619           another_range = 1;
6620         }
6621     }
6622   while (another_range);
6623
6624   *strp = str;
6625   return range;
6626 }
6627
6628 static void
6629 do_ldmstm (str)
6630      char * str;
6631 {
6632   int base_reg;
6633   long range;
6634
6635   skip_whitespace (str);
6636
6637   if ((base_reg = reg_required_here (&str, 16)) == FAIL)
6638     return;
6639
6640   if (base_reg == REG_PC)
6641     {
6642       inst.error = _("r15 not allowed as base register");
6643       return;
6644     }
6645
6646   skip_whitespace (str);
6647
6648   if (*str == '!')
6649     {
6650       inst.instruction |= WRITE_BACK;
6651       str++;
6652     }
6653
6654   if (skip_past_comma (&str) == FAIL
6655       || (range = reg_list (&str)) == FAIL)
6656     {
6657       if (! inst.error)
6658         inst.error = BAD_ARGS;
6659       return;
6660     }
6661
6662   if (*str == '^')
6663     {
6664       str++;
6665       inst.instruction |= LDM_TYPE_2_OR_3;
6666     }
6667
6668   if (inst.instruction & WRITE_BACK)
6669     {
6670       /* Check for unpredictable uses of writeback.  */
6671       if (inst.instruction & LOAD_BIT)
6672         {
6673           /* Not allowed in LDM type 2.  */
6674           if ((inst.instruction & LDM_TYPE_2_OR_3)
6675               && ((range & (1 << REG_PC)) == 0))
6676             as_warn (_("writeback of base register is UNPREDICTABLE"));
6677           /* Only allowed if base reg not in list for other types.  */
6678           else if (range & (1 << base_reg))
6679             as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
6680         }
6681       else /* STM.  */
6682         {
6683           /* Not allowed for type 2.  */
6684           if (inst.instruction & LDM_TYPE_2_OR_3)
6685             as_warn (_("writeback of base register is UNPREDICTABLE"));
6686           /* Only allowed if base reg not in list, or first in list.  */
6687           else if ((range & (1 << base_reg))
6688                    && (range & ((1 << base_reg) - 1)))
6689             as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
6690         }
6691     }
6692
6693   inst.instruction |= range;
6694   end_of_line (str);
6695   return;
6696 }
6697
6698 static void
6699 do_swi (str)
6700      char * str;
6701 {
6702   skip_whitespace (str);
6703
6704   /* Allow optional leading '#'.  */
6705   if (is_immediate_prefix (*str))
6706     str++;
6707
6708   if (my_get_expression (& inst.reloc.exp, & str))
6709     return;
6710
6711   inst.reloc.type = BFD_RELOC_ARM_SWI;
6712   inst.reloc.pc_rel = 0;
6713   end_of_line (str);
6714
6715   return;
6716 }
6717
6718 static void
6719 do_swap (str)
6720      char * str;
6721 {
6722   int reg;
6723
6724   skip_whitespace (str);
6725
6726   if ((reg = reg_required_here (&str, 12)) == FAIL)
6727     return;
6728
6729   if (reg == REG_PC)
6730     {
6731       inst.error = _("r15 not allowed in swap");
6732       return;
6733     }
6734
6735   if (skip_past_comma (&str) == FAIL
6736       || (reg = reg_required_here (&str, 0)) == FAIL)
6737     {
6738       if (!inst.error)
6739         inst.error = BAD_ARGS;
6740       return;
6741     }
6742
6743   if (reg == REG_PC)
6744     {
6745       inst.error = _("r15 not allowed in swap");
6746       return;
6747     }
6748
6749   if (skip_past_comma (&str) == FAIL
6750       || *str++ != '[')
6751     {
6752       inst.error = BAD_ARGS;
6753       return;
6754     }
6755
6756   skip_whitespace (str);
6757
6758   if ((reg = reg_required_here (&str, 16)) == FAIL)
6759     return;
6760
6761   if (reg == REG_PC)
6762     {
6763       inst.error = BAD_PC;
6764       return;
6765     }
6766
6767   skip_whitespace (str);
6768
6769   if (*str++ != ']')
6770     {
6771       inst.error = _("missing ]");
6772       return;
6773     }
6774
6775   end_of_line (str);
6776   return;
6777 }
6778
6779 static void
6780 do_branch (str)
6781      char * str;
6782 {
6783   if (my_get_expression (&inst.reloc.exp, &str))
6784     return;
6785
6786 #ifdef OBJ_ELF
6787   {
6788     char * save_in;
6789
6790     /* ScottB: February 5, 1998 - Check to see of PLT32 reloc
6791        required for the instruction.  */
6792
6793     /* arm_parse_reloc () works on input_line_pointer.
6794        We actually want to parse the operands to the branch instruction
6795        passed in 'str'.  Save the input pointer and restore it later.  */
6796     save_in = input_line_pointer;
6797     input_line_pointer = str;
6798     if (inst.reloc.exp.X_op == O_symbol
6799         && *str == '('
6800         && arm_parse_reloc () == BFD_RELOC_ARM_PLT32)
6801       {
6802         inst.reloc.type   = BFD_RELOC_ARM_PLT32;
6803         inst.reloc.pc_rel = 0;
6804         /* Modify str to point to after parsed operands, otherwise
6805            end_of_line() will complain about the (PLT) left in str.  */
6806         str = input_line_pointer;
6807       }
6808     else
6809       {
6810         inst.reloc.type   = BFD_RELOC_ARM_PCREL_BRANCH;
6811         inst.reloc.pc_rel = 1;
6812       }
6813     input_line_pointer = save_in;
6814   }
6815 #else
6816   inst.reloc.type   = BFD_RELOC_ARM_PCREL_BRANCH;
6817   inst.reloc.pc_rel = 1;
6818 #endif /* OBJ_ELF  */
6819
6820   end_of_line (str);
6821   return;
6822 }
6823
6824 static void
6825 do_bx (str)
6826      char * str;
6827 {
6828   int reg;
6829
6830   skip_whitespace (str);
6831
6832   if ((reg = reg_required_here (&str, 0)) == FAIL)
6833     {
6834       inst.error = BAD_ARGS;
6835       return;
6836     }
6837
6838   /* Note - it is not illegal to do a "bx pc".  Useless, but not illegal.  */
6839   if (reg == REG_PC)
6840     as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
6841
6842   end_of_line (str);
6843 }
6844
6845 static void
6846 do_cdp (str)
6847      char * str;
6848 {
6849   /* Co-processor data operation.
6850      Format: CDP{cond} CP#,<expr>,CRd,CRn,CRm{,<expr>}  */
6851   skip_whitespace (str);
6852
6853   if (co_proc_number (&str) == FAIL)
6854     {
6855       if (!inst.error)
6856         inst.error = BAD_ARGS;
6857       return;
6858     }
6859
6860   if (skip_past_comma (&str) == FAIL
6861       || cp_opc_expr (&str, 20,4) == FAIL)
6862     {
6863       if (!inst.error)
6864         inst.error = BAD_ARGS;
6865       return;
6866     }
6867
6868   if (skip_past_comma (&str) == FAIL
6869       || cp_reg_required_here (&str, 12) == FAIL)
6870     {
6871       if (!inst.error)
6872         inst.error = BAD_ARGS;
6873       return;
6874     }
6875
6876   if (skip_past_comma (&str) == FAIL
6877       || cp_reg_required_here (&str, 16) == FAIL)
6878     {
6879       if (!inst.error)
6880         inst.error = BAD_ARGS;
6881       return;
6882     }
6883
6884   if (skip_past_comma (&str) == FAIL
6885       || cp_reg_required_here (&str, 0) == FAIL)
6886     {
6887       if (!inst.error)
6888         inst.error = BAD_ARGS;
6889       return;
6890     }
6891
6892   if (skip_past_comma (&str) == SUCCESS)
6893     {
6894       if (cp_opc_expr (&str, 5, 3) == FAIL)
6895         {
6896           if (!inst.error)
6897             inst.error = BAD_ARGS;
6898           return;
6899         }
6900     }
6901
6902   end_of_line (str);
6903   return;
6904 }
6905
6906 static void
6907 do_lstc (str)
6908      char * str;
6909 {
6910   /* Co-processor register load/store.
6911      Format: <LDC|STC{cond}[L] CP#,CRd,<address>  */
6912
6913   skip_whitespace (str);
6914
6915   if (co_proc_number (&str) == FAIL)
6916     {
6917       if (!inst.error)
6918         inst.error = BAD_ARGS;
6919       return;
6920     }
6921
6922   if (skip_past_comma (&str) == FAIL
6923       || cp_reg_required_here (&str, 12) == FAIL)
6924     {
6925       if (!inst.error)
6926         inst.error = BAD_ARGS;
6927       return;
6928     }
6929
6930   if (skip_past_comma (&str) == FAIL
6931       || cp_address_required_here (&str, CP_WB_OK) == FAIL)
6932     {
6933       if (! inst.error)
6934         inst.error = BAD_ARGS;
6935       return;
6936     }
6937
6938   end_of_line (str);
6939   return;
6940 }
6941
6942 static void
6943 do_co_reg (str)
6944      char * str;
6945 {
6946   /* Co-processor register transfer.
6947      Format: <MCR|MRC>{cond} CP#,<expr1>,Rd,CRn,CRm{,<expr2>}  */
6948
6949   skip_whitespace (str);
6950
6951   if (co_proc_number (&str) == FAIL)
6952     {
6953       if (!inst.error)
6954         inst.error = BAD_ARGS;
6955       return;
6956     }
6957
6958   if (skip_past_comma (&str) == FAIL
6959       || cp_opc_expr (&str, 21, 3) == FAIL)
6960     {
6961       if (!inst.error)
6962         inst.error = BAD_ARGS;
6963       return;
6964     }
6965
6966   if (skip_past_comma (&str) == FAIL
6967       || reg_required_here (&str, 12) == FAIL)
6968     {
6969       if (!inst.error)
6970         inst.error = BAD_ARGS;
6971       return;
6972     }
6973
6974   if (skip_past_comma (&str) == FAIL
6975       || cp_reg_required_here (&str, 16) == FAIL)
6976     {
6977       if (!inst.error)
6978         inst.error = BAD_ARGS;
6979       return;
6980     }
6981
6982   if (skip_past_comma (&str) == FAIL
6983       || cp_reg_required_here (&str, 0) == FAIL)
6984     {
6985       if (!inst.error)
6986         inst.error = BAD_ARGS;
6987       return;
6988     }
6989
6990   if (skip_past_comma (&str) == SUCCESS)
6991     {
6992       if (cp_opc_expr (&str, 5, 3) == FAIL)
6993         {
6994           if (!inst.error)
6995             inst.error = BAD_ARGS;
6996           return;
6997         }
6998     }
6999
7000   end_of_line (str);
7001   return;
7002 }
7003
7004 static void
7005 do_fpa_ctrl (str)
7006      char * str;
7007 {
7008   /* FP control registers.
7009      Format: <WFS|RFS|WFC|RFC>{cond} Rn  */
7010
7011   skip_whitespace (str);
7012
7013   if (reg_required_here (&str, 12) == FAIL)
7014     {
7015       if (!inst.error)
7016         inst.error = BAD_ARGS;
7017       return;
7018     }
7019
7020   end_of_line (str);
7021   return;
7022 }
7023
7024 static void
7025 do_fpa_ldst (str)
7026      char * str;
7027 {
7028   skip_whitespace (str);
7029
7030   if (fp_reg_required_here (&str, 12) == FAIL)
7031     {
7032       if (!inst.error)
7033         inst.error = BAD_ARGS;
7034       return;
7035     }
7036
7037   if (skip_past_comma (&str) == FAIL
7038       || cp_address_required_here (&str, CP_WB_OK) == FAIL)
7039     {
7040       if (!inst.error)
7041         inst.error = BAD_ARGS;
7042       return;
7043     }
7044
7045   end_of_line (str);
7046 }
7047
7048 static void
7049 do_fpa_ldmstm (str)
7050      char * str;
7051 {
7052   int num_regs;
7053
7054   skip_whitespace (str);
7055
7056   if (fp_reg_required_here (&str, 12) == FAIL)
7057     {
7058       if (! inst.error)
7059         inst.error = BAD_ARGS;
7060       return;
7061     }
7062
7063   /* Get Number of registers to transfer.  */
7064   if (skip_past_comma (&str) == FAIL
7065       || my_get_expression (&inst.reloc.exp, &str))
7066     {
7067       if (! inst.error)
7068         inst.error = _("constant expression expected");
7069       return;
7070     }
7071
7072   if (inst.reloc.exp.X_op != O_constant)
7073     {
7074       inst.error = _("constant value required for number of registers");
7075       return;
7076     }
7077
7078   num_regs = inst.reloc.exp.X_add_number;
7079
7080   if (num_regs < 1 || num_regs > 4)
7081     {
7082       inst.error = _("number of registers must be in the range [1:4]");
7083       return;
7084     }
7085
7086   switch (num_regs)
7087     {
7088     case 1:
7089       inst.instruction |= CP_T_X;
7090       break;
7091     case 2:
7092       inst.instruction |= CP_T_Y;
7093       break;
7094     case 3:
7095       inst.instruction |= CP_T_Y | CP_T_X;
7096       break;
7097     case 4:
7098       break;
7099     default:
7100       abort ();
7101     }
7102
7103   if (inst.instruction & (CP_T_Pre | CP_T_UD)) /* ea/fd format.  */
7104     {
7105       int reg;
7106       int write_back;
7107       int offset;
7108
7109       /* The instruction specified "ea" or "fd", so we can only accept
7110          [Rn]{!}.  The instruction does not really support stacking or
7111          unstacking, so we have to emulate these by setting appropriate
7112          bits and offsets.  */
7113       if (skip_past_comma (&str) == FAIL
7114           || *str != '[')
7115         {
7116           if (! inst.error)
7117             inst.error = BAD_ARGS;
7118           return;
7119         }
7120
7121       str++;
7122       skip_whitespace (str);
7123
7124       if ((reg = reg_required_here (&str, 16)) == FAIL)
7125         return;
7126
7127       skip_whitespace (str);
7128
7129       if (*str != ']')
7130         {
7131           inst.error = BAD_ARGS;
7132           return;
7133         }
7134
7135       str++;
7136       if (*str == '!')
7137         {
7138           write_back = 1;
7139           str++;
7140           if (reg == REG_PC)
7141             {
7142               inst.error =
7143                 _("r15 not allowed as base register with write-back");
7144               return;
7145             }
7146         }
7147       else
7148         write_back = 0;
7149
7150       if (inst.instruction & CP_T_Pre)
7151         {
7152           /* Pre-decrement.  */
7153           offset = 3 * num_regs;
7154           if (write_back)
7155             inst.instruction |= CP_T_WB;
7156         }
7157       else
7158         {
7159           /* Post-increment.  */
7160           if (write_back)
7161             {
7162               inst.instruction |= CP_T_WB;
7163               offset = 3 * num_regs;
7164             }
7165           else
7166             {
7167               /* No write-back, so convert this into a standard pre-increment
7168                  instruction -- aesthetically more pleasing.  */
7169               inst.instruction |= CP_T_Pre | CP_T_UD;
7170               offset = 0;
7171             }
7172         }
7173
7174       inst.instruction |= offset;
7175     }
7176   else if (skip_past_comma (&str) == FAIL
7177            || cp_address_required_here (&str, CP_WB_OK) == FAIL)
7178     {
7179       if (! inst.error)
7180         inst.error = BAD_ARGS;
7181       return;
7182     }
7183
7184   end_of_line (str);
7185 }
7186
7187 static void
7188 do_fpa_dyadic (str)
7189      char * str;
7190 {
7191   skip_whitespace (str);
7192
7193   if (fp_reg_required_here (&str, 12) == FAIL)
7194     {
7195       if (! inst.error)
7196         inst.error = BAD_ARGS;
7197       return;
7198     }
7199
7200   if (skip_past_comma (&str) == FAIL
7201       || fp_reg_required_here (&str, 16) == FAIL)
7202     {
7203       if (! inst.error)
7204         inst.error = BAD_ARGS;
7205       return;
7206     }
7207
7208   if (skip_past_comma (&str) == FAIL
7209       || fp_op2 (&str) == FAIL)
7210     {
7211       if (! inst.error)
7212         inst.error = BAD_ARGS;
7213       return;
7214     }
7215
7216   end_of_line (str);
7217   return;
7218 }
7219
7220 static void
7221 do_fpa_monadic (str)
7222      char * str;
7223 {
7224   skip_whitespace (str);
7225
7226   if (fp_reg_required_here (&str, 12) == FAIL)
7227     {
7228       if (! inst.error)
7229         inst.error = BAD_ARGS;
7230       return;
7231     }
7232
7233   if (skip_past_comma (&str) == FAIL
7234       || fp_op2 (&str) == FAIL)
7235     {
7236       if (! inst.error)
7237         inst.error = BAD_ARGS;
7238       return;
7239     }
7240
7241   end_of_line (str);
7242   return;
7243 }
7244
7245 static void
7246 do_fpa_cmp (str)
7247      char * str;
7248 {
7249   skip_whitespace (str);
7250
7251   if (fp_reg_required_here (&str, 16) == FAIL)
7252     {
7253       if (! inst.error)
7254         inst.error = BAD_ARGS;
7255       return;
7256     }
7257
7258   if (skip_past_comma (&str) == FAIL
7259       || fp_op2 (&str) == FAIL)
7260     {
7261       if (! inst.error)
7262         inst.error = BAD_ARGS;
7263       return;
7264     }
7265
7266   end_of_line (str);
7267   return;
7268 }
7269
7270 static void
7271 do_fpa_from_reg (str)
7272      char * str;
7273 {
7274   skip_whitespace (str);
7275
7276   if (fp_reg_required_here (&str, 16) == FAIL)
7277     {
7278       if (! inst.error)
7279         inst.error = BAD_ARGS;
7280       return;
7281     }
7282
7283   if (skip_past_comma (&str) == FAIL
7284       || reg_required_here (&str, 12) == FAIL)
7285     {
7286       if (! inst.error)
7287         inst.error = BAD_ARGS;
7288       return;
7289     }
7290
7291   end_of_line (str);
7292   return;
7293 }
7294
7295 static void
7296 do_fpa_to_reg (str)
7297      char * str;
7298 {
7299   skip_whitespace (str);
7300
7301   if (reg_required_here (&str, 12) == FAIL)
7302     return;
7303
7304   if (skip_past_comma (&str) == FAIL
7305       || fp_reg_required_here (&str, 0) == FAIL)
7306     {
7307       if (! inst.error)
7308         inst.error = BAD_ARGS;
7309       return;
7310     }
7311
7312   end_of_line (str);
7313   return;
7314 }
7315
7316 static int
7317 vfp_sp_reg_required_here (str, pos)
7318      char **str;
7319      enum vfp_sp_reg_pos pos;
7320 {
7321   int    reg;
7322   char *start = *str;
7323
7324   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_SN].htab)) != FAIL)
7325     {
7326       switch (pos)
7327         {
7328         case VFP_REG_Sd:
7329           inst.instruction |= ((reg >> 1) << 12) | ((reg & 1) << 22);
7330           break;
7331
7332         case VFP_REG_Sn:
7333           inst.instruction |= ((reg >> 1) << 16) | ((reg & 1) << 7);
7334           break;
7335
7336         case VFP_REG_Sm:
7337           inst.instruction |= ((reg >> 1) << 0) | ((reg & 1) << 5);
7338           break;
7339
7340         default:
7341           abort ();
7342         }
7343       return reg;
7344     }
7345
7346   /* In the few cases where we might be able to accept something else
7347      this error can be overridden.  */
7348   inst.error = _(all_reg_maps[REG_TYPE_SN].expected);
7349
7350   /* Restore the start point.  */
7351   *str = start;
7352   return FAIL;
7353 }
7354
7355 static int
7356 vfp_dp_reg_required_here (str, pos)
7357      char **str;
7358      enum vfp_dp_reg_pos pos;
7359 {
7360   int   reg;
7361   char *start = *str;
7362
7363   if ((reg = arm_reg_parse (str, all_reg_maps[REG_TYPE_DN].htab)) != FAIL)
7364     {
7365       switch (pos)
7366         {
7367         case VFP_REG_Dd:
7368           inst.instruction |= reg << 12;
7369           break;
7370
7371         case VFP_REG_Dn:
7372           inst.instruction |= reg << 16;
7373           break;
7374
7375         case VFP_REG_Dm:
7376           inst.instruction |= reg << 0;
7377           break;
7378
7379         default:
7380           abort ();
7381         }
7382       return reg;
7383     }
7384
7385   /* In the few cases where we might be able to accept something else
7386      this error can be overridden.  */
7387   inst.error = _(all_reg_maps[REG_TYPE_DN].expected);
7388
7389   /* Restore the start point.  */
7390   *str = start;
7391   return FAIL;
7392 }
7393
7394 static void
7395 do_vfp_sp_monadic (str)
7396      char *str;
7397 {
7398   skip_whitespace (str);
7399
7400   if (vfp_sp_reg_required_here (&str, VFP_REG_Sd) == FAIL)
7401     return;
7402
7403   if (skip_past_comma (&str) == FAIL
7404       || vfp_sp_reg_required_here (&str, VFP_REG_Sm) == FAIL)
7405     {
7406       if (! inst.error)
7407         inst.error = BAD_ARGS;
7408       return;
7409     }
7410
7411   end_of_line (str);
7412   return;
7413 }
7414
7415 static void
7416 do_vfp_dp_monadic (str)
7417      char *str;
7418 {
7419   skip_whitespace (str);
7420
7421   if (vfp_dp_reg_required_here (&str, VFP_REG_Dd) == FAIL)
7422     return;
7423
7424   if (skip_past_comma (&str) == FAIL
7425       || vfp_dp_reg_required_here (&str, VFP_REG_Dm) == FAIL)
7426     {
7427       if (! inst.error)
7428         inst.error = BAD_ARGS;
7429       return;
7430     }
7431
7432   end_of_line (str);
7433   return;
7434 }
7435
7436 static void
7437 do_vfp_sp_dyadic (str)
7438      char *str;
7439 {
7440   skip_whitespace (str);
7441
7442   if (vfp_sp_reg_required_here (&str, VFP_REG_Sd) == FAIL)
7443     return;
7444
7445   if (skip_past_comma (&str) == FAIL
7446       || vfp_sp_reg_required_here (&str, VFP_REG_Sn) == FAIL
7447       || skip_past_comma (&str) == FAIL
7448       || vfp_sp_reg_required_here (&str, VFP_REG_Sm) == FAIL)
7449     {
7450       if (! inst.error)
7451         inst.error = BAD_ARGS;
7452       return;
7453     }
7454
7455   end_of_line (str);
7456   return;
7457 }
7458
7459 static void
7460 do_vfp_dp_dyadic (str)
7461      char *str;
7462 {
7463   skip_whitespace (str);
7464
7465   if (vfp_dp_reg_required_here (&str, VFP_REG_Dd) == FAIL)
7466     return;
7467
7468   if (skip_past_comma (&str) == FAIL
7469       || vfp_dp_reg_required_here (&str, VFP_REG_Dn) == FAIL
7470       || skip_past_comma (&str) == FAIL
7471       || vfp_dp_reg_required_here (&str, VFP_REG_Dm) == FAIL)
7472     {
7473       if (! inst.error)
7474         inst.error = BAD_ARGS;
7475       return;
7476     }
7477
7478   end_of_line (str);
7479   return;
7480 }
7481
7482 static void
7483 do_vfp_reg_from_sp (str)
7484      char *str;
7485 {
7486   skip_whitespace (str);
7487
7488   if (reg_required_here (&str, 12) == FAIL)
7489     return;
7490
7491   if (skip_past_comma (&str) == FAIL
7492       || vfp_sp_reg_required_here (&str, VFP_REG_Sn) == FAIL)
7493     {
7494       if (! inst.error)
7495         inst.error = BAD_ARGS;
7496       return;
7497     }
7498
7499   end_of_line (str);
7500   return;
7501 }
7502
7503 static void
7504 do_vfp_sp_reg2 (str)
7505      char *str;
7506 {
7507   skip_whitespace (str);
7508
7509   if (reg_required_here (&str, 12) == FAIL)
7510     return;
7511
7512   if (skip_past_comma (&str) == FAIL
7513       || reg_required_here (&str, 16) == FAIL
7514       || skip_past_comma (&str) == FAIL)
7515     {
7516       if (! inst.error)
7517         inst.error = BAD_ARGS;
7518       return;
7519     }
7520
7521   /* We require exactly two consecutive SP registers.  */
7522   if (vfp_sp_reg_list (&str, VFP_REG_Sm) != 2)
7523     {
7524       if (! inst.error)
7525         inst.error = _("only two consecutive VFP SP registers allowed here");
7526     }
7527
7528   end_of_line (str);
7529   return;
7530 }
7531
7532 static void
7533 do_vfp_sp_from_reg (str)
7534      char *str;
7535 {
7536   skip_whitespace (str);
7537
7538   if (vfp_sp_reg_required_here (&str, VFP_REG_Sn) == FAIL)
7539     return;
7540
7541   if (skip_past_comma (&str) == FAIL
7542       || reg_required_here (&str, 12) == FAIL)
7543     {
7544       if (! inst.error)
7545         inst.error = BAD_ARGS;
7546       return;
7547     }
7548
7549   end_of_line (str);
7550   return;
7551 }
7552
7553 static void
7554 do_vfp_reg_from_dp (str)
7555      char *str;
7556 {
7557   skip_whitespace (str);
7558
7559   if (reg_required_here (&str, 12) == FAIL)
7560     return;
7561
7562   if (skip_past_comma (&str) == FAIL
7563       || vfp_dp_reg_required_here (&str, VFP_REG_Dn) == FAIL)
7564     {
7565       if (! inst.error)
7566         inst.error = BAD_ARGS;
7567       return;
7568     }
7569
7570   end_of_line (str);
7571   return;
7572 }
7573
7574 static void
7575 do_vfp_reg2_from_dp (str)
7576      char *str;
7577 {
7578   skip_whitespace (str);
7579
7580   if (reg_required_here (&str, 12) == FAIL)
7581     return;
7582
7583   if (skip_past_comma (&str) == FAIL
7584       || reg_required_here (&str, 16) == FAIL
7585       || skip_past_comma (&str) == FAIL
7586       || vfp_dp_reg_required_here (&str, VFP_REG_Dm) == FAIL)
7587     {
7588       if (! inst.error)
7589         inst.error = BAD_ARGS;
7590       return;
7591     }
7592
7593   end_of_line (str);
7594   return;
7595 }
7596
7597 static void
7598 do_vfp_dp_from_reg (str)
7599      char *str;
7600 {
7601   skip_whitespace (str);
7602
7603   if (vfp_dp_reg_required_here (&str, VFP_REG_Dn) == FAIL)
7604     return;
7605
7606   if (skip_past_comma (&str) == FAIL
7607       || reg_required_here (&str, 12) == FAIL)
7608     {
7609       if (! inst.error)
7610         inst.error = BAD_ARGS;
7611       return;
7612     }
7613
7614   end_of_line (str);
7615   return;
7616 }
7617
7618 static void
7619 do_vfp_dp_from_reg2 (str)
7620      char *str;
7621 {
7622   skip_whitespace (str);
7623
7624   if (vfp_dp_reg_required_here (&str, VFP_REG_Dm) == FAIL)
7625     return;
7626
7627   if (skip_past_comma (&str) == FAIL
7628       || reg_required_here (&str, 12) == FAIL
7629       || skip_past_comma (&str) == FAIL
7630       || reg_required_here (&str, 16))
7631     {
7632       if (! inst.error)
7633         inst.error = BAD_ARGS;
7634       return;
7635     }
7636
7637   end_of_line (str);
7638   return;
7639 }
7640
7641 static const struct vfp_reg *
7642 vfp_psr_parse (str)
7643      char **str;
7644 {
7645   char *start = *str;
7646   char  c;
7647   char *p;
7648   const struct vfp_reg *vreg;
7649
7650   p = start;
7651
7652   /* Find the end of the current token.  */
7653   do
7654     {
7655       c = *p++;
7656     }
7657   while (ISALPHA (c));
7658
7659   /* Mark it.  */
7660   *--p = 0;
7661
7662   for (vreg = vfp_regs + 0;
7663        vreg < vfp_regs + sizeof (vfp_regs) / sizeof (struct vfp_reg);
7664        vreg++)
7665     {
7666       if (strcmp (start, vreg->name) == 0)
7667         {
7668           *p = c;
7669           *str = p;
7670           return vreg;
7671         }
7672     }
7673
7674   *p = c;
7675   return NULL;
7676 }
7677
7678 static int
7679 vfp_psr_required_here (str)
7680      char **str;
7681 {
7682   char *start = *str;
7683   const struct vfp_reg *vreg;
7684
7685   vreg = vfp_psr_parse (str);
7686
7687   if (vreg)
7688     {
7689       inst.instruction |= vreg->regno;
7690       return SUCCESS;
7691     }
7692
7693   inst.error = _("VFP system register expected");
7694
7695   *str = start;
7696   return FAIL;
7697 }
7698
7699 static void
7700 do_vfp_reg_from_ctrl (str)
7701      char *str;
7702 {
7703   skip_whitespace (str);
7704
7705   if (reg_required_here (&str, 12) == FAIL)
7706     return;
7707
7708   if (skip_past_comma (&str) == FAIL
7709       || vfp_psr_required_here (&str) == FAIL)
7710     {
7711       if (! inst.error)
7712         inst.error = BAD_ARGS;
7713       return;
7714     }
7715
7716   end_of_line (str);
7717   return;
7718 }
7719
7720 static void
7721 do_vfp_ctrl_from_reg (str)
7722      char *str;
7723 {
7724   skip_whitespace (str);
7725
7726   if (vfp_psr_required_here (&str) == FAIL)
7727     return;
7728
7729   if (skip_past_comma (&str) == FAIL
7730       || reg_required_here (&str, 12) == FAIL)
7731     {
7732       if (! inst.error)
7733         inst.error = BAD_ARGS;
7734       return;
7735     }
7736
7737   end_of_line (str);
7738   return;
7739 }
7740
7741 static void
7742 do_vfp_sp_ldst (str)
7743      char *str;
7744 {
7745   skip_whitespace (str);
7746
7747   if (vfp_sp_reg_required_here (&str, VFP_REG_Sd) == FAIL)
7748     {
7749       if (!inst.error)
7750         inst.error = BAD_ARGS;
7751       return;
7752     }
7753
7754   if (skip_past_comma (&str) == FAIL
7755       || cp_address_required_here (&str, CP_NO_WB) == FAIL)
7756     {
7757       if (!inst.error)
7758         inst.error = BAD_ARGS;
7759       return;
7760     }
7761
7762   end_of_line (str);
7763   return;
7764 }
7765
7766 static void
7767 do_vfp_dp_ldst (str)
7768      char *str;
7769 {
7770   skip_whitespace (str);
7771
7772   if (vfp_dp_reg_required_here (&str, VFP_REG_Dd) == FAIL)
7773     {
7774       if (!inst.error)
7775         inst.error = BAD_ARGS;
7776       return;
7777     }
7778
7779   if (skip_past_comma (&str) == FAIL
7780       || cp_address_required_here (&str, CP_NO_WB) == FAIL)
7781     {
7782       if (!inst.error)
7783         inst.error = BAD_ARGS;
7784       return;
7785     }
7786
7787   end_of_line (str);
7788   return;
7789 }
7790
7791 /* Parse and encode a VFP SP register list, storing the initial
7792    register in position POS and returning the range as the result.  If
7793    the string is invalid return FAIL (an invalid range).  */
7794 static long
7795 vfp_sp_reg_list (str, pos)
7796      char **str;
7797      enum vfp_sp_reg_pos pos;
7798 {
7799   long range = 0;
7800   int base_reg = 0;
7801   int new_base;
7802   long base_bits = 0;
7803   int count = 0;
7804   long tempinst;
7805   unsigned long mask = 0;
7806   int warned = 0;
7807
7808   if (**str != '{')
7809     return FAIL;
7810
7811   (*str)++;
7812   skip_whitespace (*str);
7813
7814   tempinst = inst.instruction;
7815
7816   do
7817     {
7818       inst.instruction = 0;
7819
7820       if ((new_base = vfp_sp_reg_required_here (str, pos)) == FAIL)
7821         return FAIL;
7822
7823       if (count == 0 || base_reg > new_base)
7824         {
7825           base_reg = new_base;
7826           base_bits = inst.instruction;
7827         }
7828
7829       if (mask & (1 << new_base))
7830         {
7831           inst.error = _("invalid register list");
7832           return FAIL;
7833         }
7834
7835       if ((mask >> new_base) != 0 && ! warned)
7836         {
7837           as_tsktsk (_("register list not in ascending order"));
7838           warned = 1;
7839         }
7840
7841       mask |= 1 << new_base;
7842       count++;
7843
7844       skip_whitespace (*str);
7845
7846       if (**str == '-') /* We have the start of a range expression */
7847         {
7848           int high_range;
7849
7850           (*str)++;
7851
7852           if ((high_range
7853                = arm_reg_parse (str, all_reg_maps[REG_TYPE_SN].htab))
7854               == FAIL)
7855             {
7856               inst.error = _(all_reg_maps[REG_TYPE_SN].expected);
7857               return FAIL;
7858             }
7859
7860           if (high_range <= new_base)
7861             {
7862               inst.error = _("register range not in ascending order");
7863               return FAIL;
7864             }
7865
7866           for (new_base++; new_base <= high_range; new_base++)
7867             {
7868               if (mask & (1 << new_base))
7869                 {
7870                   inst.error = _("invalid register list");
7871                   return FAIL;
7872                 }
7873
7874               mask |= 1 << new_base;
7875               count++;
7876             }
7877         }
7878     }
7879   while (skip_past_comma (str) != FAIL);
7880
7881   if (**str != '}')
7882     {
7883       inst.error = _("invalid register list");
7884       return FAIL;
7885     }
7886
7887   (*str)++;
7888
7889   range = count;
7890
7891   /* Sanity check -- should have raised a parse error above.  */
7892   if (count == 0 || count > 32)
7893     abort ();
7894
7895   /* Final test -- the registers must be consecutive.  */
7896   while (count--)
7897     {
7898       if ((mask & (1 << base_reg++)) == 0)
7899         {
7900           inst.error = _("non-contiguous register range");
7901           return FAIL;
7902         }
7903     }
7904
7905   inst.instruction = tempinst | base_bits;
7906   return range;
7907 }
7908
7909 static long
7910 vfp_dp_reg_list (str)
7911      char **str;
7912 {
7913   long range = 0;
7914   int base_reg = 0;
7915   int new_base;
7916   int count = 0;
7917   long tempinst;
7918   unsigned long mask = 0;
7919   int warned = 0;
7920
7921   if (**str != '{')
7922     return FAIL;
7923
7924   (*str)++;
7925   skip_whitespace (*str);
7926
7927   tempinst = inst.instruction;
7928
7929   do
7930     {
7931       inst.instruction = 0;
7932
7933       if ((new_base = vfp_dp_reg_required_here (str, VFP_REG_Dd)) == FAIL)
7934         return FAIL;
7935
7936       if (count == 0 || base_reg > new_base)
7937         {
7938           base_reg = new_base;
7939           range = inst.instruction;
7940         }
7941
7942       if (mask & (1 << new_base))
7943         {
7944           inst.error = _("invalid register list");
7945           return FAIL;
7946         }
7947
7948       if ((mask >> new_base) != 0 && ! warned)
7949         {
7950           as_tsktsk (_("register list not in ascending order"));
7951           warned = 1;
7952         }
7953
7954       mask |= 1 << new_base;
7955       count++;
7956
7957       skip_whitespace (*str);
7958
7959       if (**str == '-') /* We have the start of a range expression */
7960         {
7961           int high_range;
7962
7963           (*str)++;
7964
7965           if ((high_range
7966                = arm_reg_parse (str, all_reg_maps[REG_TYPE_DN].htab))
7967               == FAIL)
7968             {
7969               inst.error = _(all_reg_maps[REG_TYPE_DN].expected);
7970               return FAIL;
7971             }
7972
7973           if (high_range <= new_base)
7974             {
7975               inst.error = _("register range not in ascending order");
7976               return FAIL;
7977             }
7978
7979           for (new_base++; new_base <= high_range; new_base++)
7980             {
7981               if (mask & (1 << new_base))
7982                 {
7983                   inst.error = _("invalid register list");
7984                   return FAIL;
7985                 }
7986
7987               mask |= 1 << new_base;
7988               count++;
7989             }
7990         }
7991     }
7992   while (skip_past_comma (str) != FAIL);
7993
7994   if (**str != '}')
7995     {
7996       inst.error = _("invalid register list");
7997       return FAIL;
7998     }
7999
8000   (*str)++;
8001
8002   range |= 2 * count;
8003
8004   /* Sanity check -- should have raised a parse error above.  */
8005   if (count == 0 || count > 16)
8006     abort ();
8007
8008   /* Final test -- the registers must be consecutive.  */
8009   while (count--)
8010     {
8011       if ((mask & (1 << base_reg++)) == 0)
8012         {
8013           inst.error = _("non-contiguous register range");
8014           return FAIL;
8015         }
8016     }
8017
8018   inst.instruction = tempinst;
8019   return range;
8020 }
8021
8022 static void
8023 vfp_sp_ldstm (str, ldstm_type)
8024      char *str;
8025      enum vfp_ldstm_type ldstm_type;
8026 {
8027   long range;
8028
8029   skip_whitespace (str);
8030
8031   if (reg_required_here (&str, 16) == FAIL)
8032     return;
8033
8034   skip_whitespace (str);
8035
8036   if (*str == '!')
8037     {
8038       inst.instruction |= WRITE_BACK;
8039       str++;
8040     }
8041   else if (ldstm_type != VFP_LDSTMIA)
8042     {
8043       inst.error = _("this addressing mode requires base-register writeback");
8044       return;
8045     }
8046
8047   if (skip_past_comma (&str) == FAIL
8048       || (range = vfp_sp_reg_list (&str, VFP_REG_Sd)) == FAIL)
8049     {
8050       if (!inst.error)
8051         inst.error = BAD_ARGS;
8052       return;
8053     }
8054
8055   inst.instruction |= range;
8056   end_of_line (str);
8057 }
8058
8059 static void
8060 vfp_dp_ldstm (str, ldstm_type)
8061      char *str;
8062      enum vfp_ldstm_type ldstm_type;
8063 {
8064   long range;
8065
8066   skip_whitespace (str);
8067
8068   if (reg_required_here (&str, 16) == FAIL)
8069     return;
8070
8071   skip_whitespace (str);
8072
8073   if (*str == '!')
8074     {
8075       inst.instruction |= WRITE_BACK;
8076       str++;
8077     }
8078   else if (ldstm_type != VFP_LDSTMIA && ldstm_type != VFP_LDSTMIAX)
8079     {
8080       inst.error = _("this addressing mode requires base-register writeback");
8081       return;
8082     }
8083
8084   if (skip_past_comma (&str) == FAIL
8085       || (range = vfp_dp_reg_list (&str)) == FAIL)
8086     {
8087       if (!inst.error)
8088         inst.error = BAD_ARGS;
8089       return;
8090     }
8091
8092   if (ldstm_type == VFP_LDSTMIAX || ldstm_type == VFP_LDSTMDBX)
8093     range += 1;
8094
8095   inst.instruction |= range;
8096   end_of_line (str);
8097 }
8098
8099 static void
8100 do_vfp_sp_ldstmia (str)
8101      char *str;
8102 {
8103   vfp_sp_ldstm (str, VFP_LDSTMIA);
8104 }
8105
8106 static void
8107 do_vfp_sp_ldstmdb (str)
8108      char *str;
8109 {
8110   vfp_sp_ldstm (str, VFP_LDSTMDB);
8111 }
8112
8113 static void
8114 do_vfp_dp_ldstmia (str)
8115      char *str;
8116 {
8117   vfp_dp_ldstm (str, VFP_LDSTMIA);
8118 }
8119
8120 static void
8121 do_vfp_dp_ldstmdb (str)
8122      char *str;
8123 {
8124   vfp_dp_ldstm (str, VFP_LDSTMDB);
8125 }
8126
8127 static void
8128 do_vfp_xp_ldstmia (str)
8129      char *str;
8130 {
8131   vfp_dp_ldstm (str, VFP_LDSTMIAX);
8132 }
8133
8134 static void
8135 do_vfp_xp_ldstmdb (str)
8136      char *str;
8137 {
8138   vfp_dp_ldstm (str, VFP_LDSTMDBX);
8139 }
8140
8141 static void
8142 do_vfp_sp_compare_z (str)
8143      char *str;
8144 {
8145   skip_whitespace (str);
8146
8147   if (vfp_sp_reg_required_here (&str, VFP_REG_Sd) == FAIL)
8148     {
8149       if (!inst.error)
8150         inst.error = BAD_ARGS;
8151       return;
8152     }
8153
8154   end_of_line (str);
8155   return;
8156 }
8157
8158 static void
8159 do_vfp_dp_compare_z (str)
8160      char *str;
8161 {
8162   skip_whitespace (str);
8163
8164   if (vfp_dp_reg_required_here (&str, VFP_REG_Dd) == FAIL)
8165     {
8166       if (!inst.error)
8167         inst.error = BAD_ARGS;
8168       return;
8169     }
8170
8171   end_of_line (str);
8172   return;
8173 }
8174
8175 static void
8176 do_vfp_dp_sp_cvt (str)
8177      char *str;
8178 {
8179   skip_whitespace (str);
8180
8181   if (vfp_dp_reg_required_here (&str, VFP_REG_Dd) == FAIL)
8182     return;
8183
8184   if (skip_past_comma (&str) == FAIL
8185       || vfp_sp_reg_required_here (&str, VFP_REG_Sm) == FAIL)
8186     {
8187       if (! inst.error)
8188         inst.error = BAD_ARGS;
8189       return;
8190     }
8191
8192   end_of_line (str);
8193   return;
8194 }
8195
8196 static void
8197 do_vfp_sp_dp_cvt (str)
8198      char *str;
8199 {
8200   skip_whitespace (str);
8201
8202   if (vfp_sp_reg_required_here (&str, VFP_REG_Sd) == FAIL)
8203     return;
8204
8205   if (skip_past_comma (&str) == FAIL
8206       || vfp_dp_reg_required_here (&str, VFP_REG_Dm) == FAIL)
8207     {
8208       if (! inst.error)
8209         inst.error = BAD_ARGS;
8210       return;
8211     }
8212
8213   end_of_line (str);
8214   return;
8215 }
8216
8217 /* Thumb specific routines.  */
8218
8219 /* Parse and validate that a register is of the right form, this saves
8220    repeated checking of this information in many similar cases.
8221    Unlike the 32-bit case we do not insert the register into the opcode
8222    here, since the position is often unknown until the full instruction
8223    has been parsed.  */
8224
8225 static int
8226 thumb_reg (strp, hi_lo)
8227      char ** strp;
8228      int     hi_lo;
8229 {
8230   int reg;
8231
8232   if ((reg = reg_required_here (strp, -1)) == FAIL)
8233     return FAIL;
8234
8235   switch (hi_lo)
8236     {
8237     case THUMB_REG_LO:
8238       if (reg > 7)
8239         {
8240           inst.error = _("lo register required");
8241           return FAIL;
8242         }
8243       break;
8244
8245     case THUMB_REG_HI:
8246       if (reg < 8)
8247         {
8248           inst.error = _("hi register required");
8249           return FAIL;
8250         }
8251       break;
8252
8253     default:
8254       break;
8255     }
8256
8257   return reg;
8258 }
8259
8260 /* Parse an add or subtract instruction, SUBTRACT is non-zero if the opcode
8261    was SUB.  */
8262
8263 static void
8264 thumb_add_sub (str, subtract)
8265      char * str;
8266      int    subtract;
8267 {
8268   int Rd, Rs, Rn = FAIL;
8269
8270   skip_whitespace (str);
8271
8272   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
8273       || skip_past_comma (&str) == FAIL)
8274     {
8275       if (! inst.error)
8276         inst.error = BAD_ARGS;
8277       return;
8278     }
8279
8280   if (is_immediate_prefix (*str))
8281     {
8282       Rs = Rd;
8283       str++;
8284       if (my_get_expression (&inst.reloc.exp, &str))
8285         return;
8286     }
8287   else
8288     {
8289       if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
8290         return;
8291
8292       if (skip_past_comma (&str) == FAIL)
8293         {
8294           /* Two operand format, shuffle the registers
8295              and pretend there are 3.  */
8296           Rn = Rs;
8297           Rs = Rd;
8298         }
8299       else if (is_immediate_prefix (*str))
8300         {
8301           str++;
8302           if (my_get_expression (&inst.reloc.exp, &str))
8303             return;
8304         }
8305       else if ((Rn = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
8306         return;
8307     }
8308
8309   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
8310      for the latter case, EXPR contains the immediate that was found.  */
8311   if (Rn != FAIL)
8312     {
8313       /* All register format.  */
8314       if (Rd > 7 || Rs > 7 || Rn > 7)
8315         {
8316           if (Rs != Rd)
8317             {
8318               inst.error = _("dest and source1 must be the same register");
8319               return;
8320             }
8321
8322           /* Can't do this for SUB.  */
8323           if (subtract)
8324             {
8325               inst.error = _("subtract valid only on lo regs");
8326               return;
8327             }
8328
8329           inst.instruction = (T_OPCODE_ADD_HI
8330                               | (Rd > 7 ? THUMB_H1 : 0)
8331                               | (Rn > 7 ? THUMB_H2 : 0));
8332           inst.instruction |= (Rd & 7) | ((Rn & 7) << 3);
8333         }
8334       else
8335         {
8336           inst.instruction = subtract ? T_OPCODE_SUB_R3 : T_OPCODE_ADD_R3;
8337           inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
8338         }
8339     }
8340   else
8341     {
8342       /* Immediate expression, now things start to get nasty.  */
8343
8344       /* First deal with HI regs, only very restricted cases allowed:
8345          Adjusting SP, and using PC or SP to get an address.  */
8346       if ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
8347           || (Rs > 7 && Rs != REG_SP && Rs != REG_PC))
8348         {
8349           inst.error = _("invalid Hi register with immediate");
8350           return;
8351         }
8352
8353       if (inst.reloc.exp.X_op != O_constant)
8354         {
8355           /* Value isn't known yet, all we can do is store all the fragments
8356              we know about in the instruction and let the reloc hacking
8357              work it all out.  */
8358           inst.instruction = (subtract ? 0x8000 : 0) | (Rd << 4) | Rs;
8359           inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
8360         }
8361       else
8362         {
8363           int offset = inst.reloc.exp.X_add_number;
8364
8365           if (subtract)
8366             offset = - offset;
8367
8368           if (offset < 0)
8369             {
8370               offset = - offset;
8371               subtract = 1;
8372
8373               /* Quick check, in case offset is MIN_INT.  */
8374               if (offset < 0)
8375                 {
8376                   inst.error = _("immediate value out of range");
8377                   return;
8378                 }
8379             }
8380           /* Note - you cannot convert a subtract of 0 into an
8381              add of 0 because the carry flag is set differently.  */
8382           else if (offset > 0)
8383             subtract = 0;
8384
8385           if (Rd == REG_SP)
8386             {
8387               if (offset & ~0x1fc)
8388                 {
8389                   inst.error = _("invalid immediate value for stack adjust");
8390                   return;
8391                 }
8392               inst.instruction = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
8393               inst.instruction |= offset >> 2;
8394             }
8395           else if (Rs == REG_PC || Rs == REG_SP)
8396             {
8397               if (subtract
8398                   || (offset & ~0x3fc))
8399                 {
8400                   inst.error = _("invalid immediate for address calculation");
8401                   return;
8402                 }
8403               inst.instruction = (Rs == REG_PC ? T_OPCODE_ADD_PC
8404                                   : T_OPCODE_ADD_SP);
8405               inst.instruction |= (Rd << 8) | (offset >> 2);
8406             }
8407           else if (Rs == Rd)
8408             {
8409               if (offset & ~0xff)
8410                 {
8411                   inst.error = _("immediate value out of range");
8412                   return;
8413                 }
8414               inst.instruction = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
8415               inst.instruction |= (Rd << 8) | offset;
8416             }
8417           else
8418             {
8419               if (offset & ~0x7)
8420                 {
8421                   inst.error = _("immediate value out of range");
8422                   return;
8423                 }
8424               inst.instruction = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
8425               inst.instruction |= Rd | (Rs << 3) | (offset << 6);
8426             }
8427         }
8428     }
8429
8430   end_of_line (str);
8431 }
8432
8433 static void
8434 thumb_shift (str, shift)
8435      char * str;
8436      int    shift;
8437 {
8438   int Rd, Rs, Rn = FAIL;
8439
8440   skip_whitespace (str);
8441
8442   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
8443       || skip_past_comma (&str) == FAIL)
8444     {
8445       if (! inst.error)
8446         inst.error = BAD_ARGS;
8447       return;
8448     }
8449
8450   if (is_immediate_prefix (*str))
8451     {
8452       /* Two operand immediate format, set Rs to Rd.  */
8453       Rs = Rd;
8454       str ++;
8455       if (my_get_expression (&inst.reloc.exp, &str))
8456         return;
8457     }
8458   else
8459     {
8460       if ((Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
8461         return;
8462
8463       if (skip_past_comma (&str) == FAIL)
8464         {
8465           /* Two operand format, shuffle the registers
8466              and pretend there are 3.  */
8467           Rn = Rs;
8468           Rs = Rd;
8469         }
8470       else if (is_immediate_prefix (*str))
8471         {
8472           str++;
8473           if (my_get_expression (&inst.reloc.exp, &str))
8474             return;
8475         }
8476       else if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
8477         return;
8478     }
8479
8480   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
8481      for the latter case, EXPR contains the immediate that was found.  */
8482
8483   if (Rn != FAIL)
8484     {
8485       if (Rs != Rd)
8486         {
8487           inst.error = _("source1 and dest must be same register");
8488           return;
8489         }
8490
8491       switch (shift)
8492         {
8493         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_R; break;
8494         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_R; break;
8495         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_R; break;
8496         }
8497
8498       inst.instruction |= Rd | (Rn << 3);
8499     }
8500   else
8501     {
8502       switch (shift)
8503         {
8504         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_I; break;
8505         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_I; break;
8506         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_I; break;
8507         }
8508
8509       if (inst.reloc.exp.X_op != O_constant)
8510         {
8511           /* Value isn't known yet, create a dummy reloc and let reloc
8512              hacking fix it up.  */
8513           inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
8514         }
8515       else
8516         {
8517           unsigned shift_value = inst.reloc.exp.X_add_number;
8518
8519           if (shift_value > 32 || (shift_value == 32 && shift == THUMB_LSL))
8520             {
8521               inst.error = _("invalid immediate for shift");
8522               return;
8523             }
8524
8525           /* Shifts of zero are handled by converting to LSL.  */
8526           if (shift_value == 0)
8527             inst.instruction = T_OPCODE_LSL_I;
8528
8529           /* Shifts of 32 are encoded as a shift of zero.  */
8530           if (shift_value == 32)
8531             shift_value = 0;
8532
8533           inst.instruction |= shift_value << 6;
8534         }
8535
8536       inst.instruction |= Rd | (Rs << 3);
8537     }
8538
8539   end_of_line (str);
8540 }
8541
8542 static void
8543 thumb_mov_compare (str, move)
8544      char * str;
8545      int    move;
8546 {
8547   int Rd, Rs = FAIL;
8548
8549   skip_whitespace (str);
8550
8551   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
8552       || skip_past_comma (&str) == FAIL)
8553     {
8554       if (! inst.error)
8555         inst.error = BAD_ARGS;
8556       return;
8557     }
8558
8559   if (is_immediate_prefix (*str))
8560     {
8561       str++;
8562       if (my_get_expression (&inst.reloc.exp, &str))
8563         return;
8564     }
8565   else if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
8566     return;
8567
8568   if (Rs != FAIL)
8569     {
8570       if (Rs < 8 && Rd < 8)
8571         {
8572           if (move == THUMB_MOVE)
8573             /* A move of two lowregs is encoded as ADD Rd, Rs, #0
8574                since a MOV instruction produces unpredictable results.  */
8575             inst.instruction = T_OPCODE_ADD_I3;
8576           else
8577             inst.instruction = T_OPCODE_CMP_LR;
8578           inst.instruction |= Rd | (Rs << 3);
8579         }
8580       else
8581         {
8582           if (move == THUMB_MOVE)
8583             inst.instruction = T_OPCODE_MOV_HR;
8584           else
8585             inst.instruction = T_OPCODE_CMP_HR;
8586
8587           if (Rd > 7)
8588             inst.instruction |= THUMB_H1;
8589
8590           if (Rs > 7)
8591             inst.instruction |= THUMB_H2;
8592
8593           inst.instruction |= (Rd & 7) | ((Rs & 7) << 3);
8594         }
8595     }
8596   else
8597     {
8598       if (Rd > 7)
8599         {
8600           inst.error = _("only lo regs allowed with immediate");
8601           return;
8602         }
8603
8604       if (move == THUMB_MOVE)
8605         inst.instruction = T_OPCODE_MOV_I8;
8606       else
8607         inst.instruction = T_OPCODE_CMP_I8;
8608
8609       inst.instruction |= Rd << 8;
8610
8611       if (inst.reloc.exp.X_op != O_constant)
8612         inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
8613       else
8614         {
8615           unsigned value = inst.reloc.exp.X_add_number;
8616
8617           if (value > 255)
8618             {
8619               inst.error = _("invalid immediate");
8620               return;
8621             }
8622
8623           inst.instruction |= value;
8624         }
8625     }
8626
8627   end_of_line (str);
8628 }
8629
8630 static void
8631 thumb_load_store (str, load_store, size)
8632      char * str;
8633      int    load_store;
8634      int    size;
8635 {
8636   int Rd, Rb, Ro = FAIL;
8637
8638   skip_whitespace (str);
8639
8640   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
8641       || skip_past_comma (&str) == FAIL)
8642     {
8643       if (! inst.error)
8644         inst.error = BAD_ARGS;
8645       return;
8646     }
8647
8648   if (*str == '[')
8649     {
8650       str++;
8651       if ((Rb = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
8652         return;
8653
8654       if (skip_past_comma (&str) != FAIL)
8655         {
8656           if (is_immediate_prefix (*str))
8657             {
8658               str++;
8659               if (my_get_expression (&inst.reloc.exp, &str))
8660                 return;
8661             }
8662           else if ((Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
8663             return;
8664         }
8665       else
8666         {
8667           inst.reloc.exp.X_op = O_constant;
8668           inst.reloc.exp.X_add_number = 0;
8669         }
8670
8671       if (*str != ']')
8672         {
8673           inst.error = _("expected ']'");
8674           return;
8675         }
8676       str++;
8677     }
8678   else if (*str == '=')
8679     {
8680       if (load_store != THUMB_LOAD)
8681         {
8682           inst.error = _("invalid pseudo operation");
8683           return;
8684         }
8685
8686       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
8687       str++;
8688
8689       skip_whitespace (str);
8690
8691       if (my_get_expression (& inst.reloc.exp, & str))
8692         return;
8693
8694       end_of_line (str);
8695
8696       if (   inst.reloc.exp.X_op != O_constant
8697           && inst.reloc.exp.X_op != O_symbol)
8698         {
8699           inst.error = "Constant expression expected";
8700           return;
8701         }
8702
8703       if (inst.reloc.exp.X_op == O_constant
8704           && ((inst.reloc.exp.X_add_number & ~0xFF) == 0))
8705         {
8706           /* This can be done with a mov instruction.  */
8707
8708           inst.instruction  = T_OPCODE_MOV_I8 | (Rd << 8);
8709           inst.instruction |= inst.reloc.exp.X_add_number;
8710           return;
8711         }
8712
8713       /* Insert into literal pool.  */
8714       if (add_to_lit_pool () == FAIL)
8715         {
8716           if (!inst.error)
8717             inst.error = "literal pool insertion failed";
8718           return;
8719         }
8720
8721       inst.reloc.type   = BFD_RELOC_ARM_THUMB_OFFSET;
8722       inst.reloc.pc_rel = 1;
8723       inst.instruction  = T_OPCODE_LDR_PC | (Rd << 8);
8724       /* Adjust ARM pipeline offset to Thumb.  */
8725       inst.reloc.exp.X_add_number += 4;
8726
8727       return;
8728     }
8729   else
8730     {
8731       if (my_get_expression (&inst.reloc.exp, &str))
8732         return;
8733
8734       inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
8735       inst.reloc.pc_rel = 1;
8736       inst.reloc.exp.X_add_number -= 4; /* Pipeline offset.  */
8737       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
8738       end_of_line (str);
8739       return;
8740     }
8741
8742   if (Rb == REG_PC || Rb == REG_SP)
8743     {
8744       if (size != THUMB_WORD)
8745         {
8746           inst.error = _("byte or halfword not valid for base register");
8747           return;
8748         }
8749       else if (Rb == REG_PC && load_store != THUMB_LOAD)
8750         {
8751           inst.error = _("r15 based store not allowed");
8752           return;
8753         }
8754       else if (Ro != FAIL)
8755         {
8756           inst.error = _("invalid base register for register offset");
8757           return;
8758         }
8759
8760       if (Rb == REG_PC)
8761         inst.instruction = T_OPCODE_LDR_PC;
8762       else if (load_store == THUMB_LOAD)
8763         inst.instruction = T_OPCODE_LDR_SP;
8764       else
8765         inst.instruction = T_OPCODE_STR_SP;
8766
8767       inst.instruction |= Rd << 8;
8768       if (inst.reloc.exp.X_op == O_constant)
8769         {
8770           unsigned offset = inst.reloc.exp.X_add_number;
8771
8772           if (offset & ~0x3fc)
8773             {
8774               inst.error = _("invalid offset");
8775               return;
8776             }
8777
8778           inst.instruction |= offset >> 2;
8779         }
8780       else
8781         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
8782     }
8783   else if (Rb > 7)
8784     {
8785       inst.error = _("invalid base register in load/store");
8786       return;
8787     }
8788   else if (Ro == FAIL)
8789     {
8790       /* Immediate offset.  */
8791       if (size == THUMB_WORD)
8792         inst.instruction = (load_store == THUMB_LOAD
8793                             ? T_OPCODE_LDR_IW : T_OPCODE_STR_IW);
8794       else if (size == THUMB_HALFWORD)
8795         inst.instruction = (load_store == THUMB_LOAD
8796                             ? T_OPCODE_LDR_IH : T_OPCODE_STR_IH);
8797       else
8798         inst.instruction = (load_store == THUMB_LOAD
8799                             ? T_OPCODE_LDR_IB : T_OPCODE_STR_IB);
8800
8801       inst.instruction |= Rd | (Rb << 3);
8802
8803       if (inst.reloc.exp.X_op == O_constant)
8804         {
8805           unsigned offset = inst.reloc.exp.X_add_number;
8806
8807           if (offset & ~(0x1f << size))
8808             {
8809               inst.error = _("invalid offset");
8810               return;
8811             }
8812           inst.instruction |= (offset >> size) << 6;
8813         }
8814       else
8815         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
8816     }
8817   else
8818     {
8819       /* Register offset.  */
8820       if (size == THUMB_WORD)
8821         inst.instruction = (load_store == THUMB_LOAD
8822                             ? T_OPCODE_LDR_RW : T_OPCODE_STR_RW);
8823       else if (size == THUMB_HALFWORD)
8824         inst.instruction = (load_store == THUMB_LOAD
8825                             ? T_OPCODE_LDR_RH : T_OPCODE_STR_RH);
8826       else
8827         inst.instruction = (load_store == THUMB_LOAD
8828                             ? T_OPCODE_LDR_RB : T_OPCODE_STR_RB);
8829
8830       inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
8831     }
8832
8833   end_of_line (str);
8834 }
8835
8836 /* A register must be given at this point.
8837
8838    Shift is the place to put it in inst.instruction.
8839
8840    Restores input start point on err.
8841    Returns the reg#, or FAIL.  */
8842
8843 static int
8844 mav_reg_required_here (str, shift, regtype)
8845      char ** str;
8846      int shift;
8847      enum arm_reg_type regtype;
8848 {
8849   int   reg;
8850   char *start = *str;
8851
8852   if ((reg = arm_reg_parse (str, all_reg_maps[regtype].htab)) != FAIL)
8853     {
8854       if (shift >= 0)
8855         inst.instruction |= reg << shift;
8856
8857       return reg;
8858     }
8859
8860   /* Restore the start point.  */
8861   *str = start;
8862
8863   /* In the few cases where we might be able to accept something else
8864      this error can be overridden.  */
8865   inst.error = _(all_reg_maps[regtype].expected);
8866
8867   return FAIL;
8868 }
8869
8870 /* Cirrus Maverick Instructions.  */
8871
8872 /* Wrapper functions.  */
8873
8874 static void
8875 do_mav_binops_1a (str)
8876      char * str;
8877 {
8878   do_mav_binops (str, MAV_MODE1, REG_TYPE_RN, REG_TYPE_MVF);
8879 }
8880
8881 static void
8882 do_mav_binops_1b (str)
8883      char * str;
8884 {
8885   do_mav_binops (str, MAV_MODE1, REG_TYPE_RN, REG_TYPE_MVD);
8886 }
8887
8888 static void
8889 do_mav_binops_1c (str)
8890      char * str;
8891 {
8892   do_mav_binops (str, MAV_MODE1, REG_TYPE_RN, REG_TYPE_MVDX);
8893 }
8894
8895 static void
8896 do_mav_binops_1d (str)
8897      char * str;
8898 {
8899   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVF, REG_TYPE_MVF);
8900 }
8901
8902 static void
8903 do_mav_binops_1e (str)
8904      char * str;
8905 {
8906   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVD, REG_TYPE_MVD);
8907 }
8908
8909 static void
8910 do_mav_binops_1f (str)
8911      char * str;
8912 {
8913   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVD, REG_TYPE_MVF);
8914 }
8915
8916 static void
8917 do_mav_binops_1g (str)
8918      char * str;
8919 {
8920   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVF, REG_TYPE_MVD);
8921 }
8922
8923 static void
8924 do_mav_binops_1h (str)
8925      char * str;
8926 {
8927   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVF, REG_TYPE_MVFX);
8928 }
8929
8930 static void
8931 do_mav_binops_1i (str)
8932      char * str;
8933 {
8934   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVD, REG_TYPE_MVFX);
8935 }
8936
8937 static void
8938 do_mav_binops_1j (str)
8939      char * str;
8940 {
8941   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVF, REG_TYPE_MVDX);
8942 }
8943
8944 static void
8945 do_mav_binops_1k (str)
8946      char * str;
8947 {
8948   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVD, REG_TYPE_MVDX);
8949 }
8950
8951 static void
8952 do_mav_binops_1l (str)
8953      char * str;
8954 {
8955   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVFX, REG_TYPE_MVF);
8956 }
8957
8958 static void
8959 do_mav_binops_1m (str)
8960      char * str;
8961 {
8962   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVFX, REG_TYPE_MVD);
8963 }
8964
8965 static void
8966 do_mav_binops_1n (str)
8967      char * str;
8968 {
8969   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVFX, REG_TYPE_MVFX);
8970 }
8971
8972 static void
8973 do_mav_binops_1o (str)
8974      char * str;
8975 {
8976   do_mav_binops (str, MAV_MODE1, REG_TYPE_MVDX, REG_TYPE_MVDX);
8977 }
8978
8979 static void
8980 do_mav_binops_2a (str)
8981      char * str;
8982 {
8983   do_mav_binops (str, MAV_MODE2, REG_TYPE_MVF, REG_TYPE_RN);
8984 }
8985
8986 static void
8987 do_mav_binops_2b (str)
8988      char * str;
8989 {
8990   do_mav_binops (str, MAV_MODE2, REG_TYPE_MVD, REG_TYPE_RN);
8991 }
8992
8993 static void
8994 do_mav_binops_2c (str)
8995      char * str;
8996 {
8997   do_mav_binops (str, MAV_MODE2, REG_TYPE_MVDX, REG_TYPE_RN);
8998 }
8999
9000 static void
9001 do_mav_binops_3a (str)
9002      char * str;
9003 {
9004   do_mav_binops (str, MAV_MODE3, REG_TYPE_MVAX, REG_TYPE_MVFX);
9005 }
9006
9007 static void
9008 do_mav_binops_3b (str)
9009      char * str;
9010 {
9011   do_mav_binops (str, MAV_MODE3, REG_TYPE_MVFX, REG_TYPE_MVAX);
9012 }
9013
9014 static void
9015 do_mav_binops_3c (str)
9016      char * str;
9017 {
9018   do_mav_binops (str, MAV_MODE3, REG_TYPE_MVAX, REG_TYPE_MVDX);
9019 }
9020
9021 static void
9022 do_mav_binops_3d (str)
9023      char * str;
9024 {
9025   do_mav_binops (str, MAV_MODE3, REG_TYPE_MVDX, REG_TYPE_MVAX);
9026 }
9027
9028 static void
9029 do_mav_triple_4a (str)
9030      char * str;
9031 {
9032   do_mav_triple (str, MAV_MODE4, REG_TYPE_MVFX, REG_TYPE_MVFX, REG_TYPE_RN);
9033 }
9034
9035 static void
9036 do_mav_triple_4b (str)
9037      char * str;
9038 {
9039   do_mav_triple (str, MAV_MODE4, REG_TYPE_MVDX, REG_TYPE_MVDX, REG_TYPE_RN);
9040 }
9041
9042 static void
9043 do_mav_triple_5a (str)
9044      char * str;
9045 {
9046   do_mav_triple (str, MAV_MODE5, REG_TYPE_RN, REG_TYPE_MVF, REG_TYPE_MVF);
9047 }
9048
9049 static void
9050 do_mav_triple_5b (str)
9051      char * str;
9052 {
9053   do_mav_triple (str, MAV_MODE5, REG_TYPE_RN, REG_TYPE_MVD, REG_TYPE_MVD);
9054 }
9055
9056 static void
9057 do_mav_triple_5c (str)
9058      char * str;
9059 {
9060   do_mav_triple (str, MAV_MODE5, REG_TYPE_RN, REG_TYPE_MVFX, REG_TYPE_MVFX);
9061 }
9062
9063 static void
9064 do_mav_triple_5d (str)
9065      char * str;
9066 {
9067   do_mav_triple (str, MAV_MODE5, REG_TYPE_RN, REG_TYPE_MVDX, REG_TYPE_MVDX);
9068 }
9069
9070 static void
9071 do_mav_triple_5e (str)
9072      char * str;
9073 {
9074   do_mav_triple (str, MAV_MODE5, REG_TYPE_MVF, REG_TYPE_MVF, REG_TYPE_MVF);
9075 }
9076
9077 static void
9078 do_mav_triple_5f (str)
9079      char * str;
9080 {
9081   do_mav_triple (str, MAV_MODE5, REG_TYPE_MVD, REG_TYPE_MVD, REG_TYPE_MVD);
9082 }
9083
9084 static void
9085 do_mav_triple_5g (str)
9086      char * str;
9087 {
9088   do_mav_triple (str, MAV_MODE5, REG_TYPE_MVFX, REG_TYPE_MVFX, REG_TYPE_MVFX);
9089 }
9090
9091 static void
9092 do_mav_triple_5h (str)
9093      char * str;
9094 {
9095   do_mav_triple (str, MAV_MODE5, REG_TYPE_MVDX, REG_TYPE_MVDX, REG_TYPE_MVDX);
9096 }
9097
9098 static void
9099 do_mav_quad_6a (str)
9100      char * str;
9101 {
9102   do_mav_quad (str, MAV_MODE6, REG_TYPE_MVAX, REG_TYPE_MVFX, REG_TYPE_MVFX,
9103              REG_TYPE_MVFX);
9104 }
9105
9106 static void
9107 do_mav_quad_6b (str)
9108      char * str;
9109 {
9110   do_mav_quad (str, MAV_MODE6, REG_TYPE_MVAX, REG_TYPE_MVAX, REG_TYPE_MVFX,
9111              REG_TYPE_MVFX);
9112 }
9113
9114 /* cfmvsc32<cond> DSPSC,MVFX[15:0].  */
9115 static void
9116 do_mav_dspsc_1 (str)
9117      char * str;
9118 {
9119   skip_whitespace (str);
9120
9121   /* cfmvsc32.  */
9122   if (mav_reg_required_here (&str, -1, REG_TYPE_DSPSC) == FAIL
9123       || skip_past_comma (&str) == FAIL
9124       || mav_reg_required_here (&str, 16, REG_TYPE_MVFX) == FAIL)
9125     {
9126       if (!inst.error)
9127         inst.error = BAD_ARGS;
9128
9129       return;
9130     }
9131
9132   end_of_line (str);
9133 }
9134
9135 /* cfmv32sc<cond> MVFX[15:0],DSPSC.  */
9136 static void
9137 do_mav_dspsc_2 (str)
9138      char * str;
9139 {
9140   skip_whitespace (str);
9141
9142   /* cfmv32sc.  */
9143   if (mav_reg_required_here (&str, 0, REG_TYPE_MVFX) == FAIL
9144       || skip_past_comma (&str) == FAIL
9145       || mav_reg_required_here (&str, -1, REG_TYPE_DSPSC) == FAIL)
9146     {
9147       if (!inst.error)
9148         inst.error = BAD_ARGS;
9149
9150       return;
9151     }
9152
9153   end_of_line (str);
9154 }
9155
9156 static void
9157 do_mav_shift_1 (str)
9158      char * str;
9159 {
9160   do_mav_shift (str, REG_TYPE_MVFX, REG_TYPE_MVFX);
9161 }
9162
9163 static void
9164 do_mav_shift_2 (str)
9165      char * str;
9166 {
9167   do_mav_shift (str, REG_TYPE_MVDX, REG_TYPE_MVDX);
9168 }
9169
9170 static void
9171 do_mav_ldst_1 (str)
9172      char * str;
9173 {
9174   do_mav_ldst (str, REG_TYPE_MVF);
9175 }
9176
9177 static void
9178 do_mav_ldst_2 (str)
9179      char * str;
9180 {
9181   do_mav_ldst (str, REG_TYPE_MVD);
9182 }
9183
9184 static void
9185 do_mav_ldst_3 (str)
9186      char * str;
9187 {
9188   do_mav_ldst (str, REG_TYPE_MVFX);
9189 }
9190
9191 static void
9192 do_mav_ldst_4 (str)
9193      char * str;
9194 {
9195   do_mav_ldst (str, REG_TYPE_MVDX);
9196 }
9197
9198 /* Isnsn like "foo X,Y".  */
9199
9200 static void
9201 do_mav_binops (str, mode, reg0, reg1)
9202      char * str;
9203      int mode;
9204      enum arm_reg_type reg0;
9205      enum arm_reg_type reg1;
9206 {
9207   int shift0, shift1;
9208
9209   shift0 = mode & 0xff;
9210   shift1 = (mode >> 8) & 0xff;
9211
9212   skip_whitespace (str);
9213
9214   if (mav_reg_required_here (&str, shift0, reg0) == FAIL
9215       || skip_past_comma (&str) == FAIL
9216       || mav_reg_required_here (&str, shift1, reg1) == FAIL)
9217     {
9218       if (!inst.error)
9219         inst.error = BAD_ARGS;
9220     }
9221   else
9222     end_of_line (str);
9223 }
9224
9225 /* Isnsn like "foo X,Y,Z".  */
9226
9227 static void
9228 do_mav_triple (str, mode, reg0, reg1, reg2)
9229      char * str;
9230      int mode;
9231      enum arm_reg_type reg0;
9232      enum arm_reg_type reg1;
9233      enum arm_reg_type reg2;
9234 {
9235   int shift0, shift1, shift2;
9236
9237   shift0 = mode & 0xff;
9238   shift1 = (mode >> 8) & 0xff;
9239   shift2 = (mode >> 16) & 0xff;
9240
9241   skip_whitespace (str);
9242
9243   if (mav_reg_required_here (&str, shift0, reg0) == FAIL
9244       || skip_past_comma (&str) == FAIL
9245       || mav_reg_required_here (&str, shift1, reg1) == FAIL
9246       || skip_past_comma (&str) == FAIL
9247       || mav_reg_required_here (&str, shift2, reg2) == FAIL)
9248     {
9249       if (!inst.error)
9250         inst.error = BAD_ARGS;
9251     }
9252   else
9253     end_of_line (str);
9254 }
9255
9256 /* Isnsn like "foo W,X,Y,Z".
9257     where W=MVAX[0:3] and X,Y,Z=MVFX[0:15].  */
9258
9259 static void
9260 do_mav_quad (str, mode, reg0, reg1, reg2, reg3)
9261      char * str;
9262      int mode;
9263      enum arm_reg_type reg0;
9264      enum arm_reg_type reg1;
9265      enum arm_reg_type reg2;
9266      enum arm_reg_type reg3;
9267 {
9268   int shift0, shift1, shift2, shift3;
9269
9270   shift0= mode & 0xff;
9271   shift1 = (mode >> 8) & 0xff;
9272   shift2 = (mode >> 16) & 0xff;
9273   shift3 = (mode >> 24) & 0xff;
9274
9275   skip_whitespace (str);
9276
9277   if (mav_reg_required_here (&str, shift0, reg0) == FAIL
9278       || skip_past_comma (&str) == FAIL
9279       || mav_reg_required_here (&str, shift1, reg1) == FAIL
9280       || skip_past_comma (&str) == FAIL
9281       || mav_reg_required_here (&str, shift2, reg2) == FAIL
9282       || skip_past_comma (&str) == FAIL
9283       || mav_reg_required_here (&str, shift3, reg3) == FAIL)
9284     {
9285       if (!inst.error)
9286         inst.error = BAD_ARGS;
9287     }
9288   else
9289     end_of_line (str);
9290 }
9291
9292 /* Maverick shift immediate instructions.
9293    cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
9294    cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0].  */
9295
9296 static void
9297 do_mav_shift (str, reg0, reg1)
9298      char * str;
9299      enum arm_reg_type reg0;
9300      enum arm_reg_type reg1;
9301 {
9302   int error;
9303   int imm, neg = 0;
9304
9305   skip_whitespace (str);
9306
9307   error = 0;
9308
9309   if (mav_reg_required_here (&str, 12, reg0) == FAIL
9310       || skip_past_comma (&str) == FAIL
9311       || mav_reg_required_here (&str, 16, reg1) == FAIL
9312       || skip_past_comma  (&str) == FAIL)
9313     {
9314       if (!inst.error)
9315         inst.error = BAD_ARGS;
9316       return;
9317     }
9318
9319   /* Calculate the immediate operand.
9320      The operand is a 7bit signed number.  */
9321   skip_whitespace (str);
9322
9323   if (*str == '#')
9324     ++str;
9325
9326   if (!ISDIGIT (*str) && *str != '-')
9327     {
9328       inst.error = _("expecting immediate, 7bit operand");
9329       return;
9330     }
9331
9332   if (*str == '-')
9333     {
9334       neg = 1;
9335       ++str;
9336     }
9337
9338   for (imm = 0; *str && ISDIGIT (*str); ++str)
9339     imm = imm * 10 + *str - '0';
9340
9341   if (imm > 64)
9342     {
9343       inst.error = _("immediate out of range");
9344       return;
9345     }
9346
9347   /* Make negative imm's into 7bit signed numbers.  */
9348   if (neg)
9349     {
9350       imm = -imm;
9351       imm &= 0x0000007f;
9352     }
9353
9354   /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
9355      Bits 5-7 of the insn should have bits 4-6 of the immediate.
9356      Bit 4 should be 0.  */
9357   imm = (imm & 0xf) | ((imm & 0x70) << 1);
9358
9359   inst.instruction |= imm;
9360   end_of_line (str);
9361 }
9362
9363 static int
9364 mav_parse_offset (str, negative)
9365      char ** str;
9366      int *negative;
9367 {
9368   char * p = *str;
9369   int offset;
9370
9371   *negative = 0;
9372
9373   skip_whitespace (p);
9374
9375   if (*p == '#')
9376     ++p;
9377
9378   if (*p == '-')
9379     {
9380       *negative = 1;
9381       ++p;
9382     }
9383
9384   if (!ISDIGIT (*p))
9385     {
9386       inst.error = _("offset expected");
9387       return 0;
9388     }
9389
9390   for (offset = 0; *p && ISDIGIT (*p); ++p)
9391     offset = offset * 10 + *p - '0';
9392
9393   if (offset > 0xff)
9394     {
9395       inst.error = _("offset out of range");
9396       return 0;
9397     }
9398
9399   *str = p;
9400
9401   return *negative ? -offset : offset;
9402 }
9403
9404 /* Maverick load/store instructions.
9405   <insn><cond> CRd,[Rn,<offset>]{!}.
9406   <insn><cond> CRd,[Rn],<offset>.  */
9407
9408 static void
9409 do_mav_ldst (str, reg0)
9410      char * str;
9411      enum arm_reg_type reg0;
9412 {
9413   int offset, negative;
9414
9415   skip_whitespace (str);
9416
9417   if (mav_reg_required_here (&str, 12, reg0) == FAIL
9418       || skip_past_comma (&str) == FAIL
9419       || *str++ != '['
9420       || reg_required_here (&str, 16) == FAIL)
9421     goto fail_ldst;
9422
9423   if (skip_past_comma (&str) == SUCCESS)
9424     {
9425       /* You are here: "<offset>]{!}".  */
9426       inst.instruction |= PRE_INDEX;
9427
9428       offset = mav_parse_offset (&str, &negative);
9429
9430       if (inst.error)
9431         return;
9432
9433       if (*str++ != ']')
9434         {
9435           inst.error = _("missing ]");
9436           return;
9437         }
9438
9439       if (*str == '!')
9440         {
9441           inst.instruction |= WRITE_BACK;
9442           ++str;
9443         }
9444     }
9445   else
9446     {
9447       /* You are here: "], <offset>".  */
9448       if (*str++ != ']')
9449         {
9450           inst.error = _("missing ]");
9451           return;
9452         }
9453
9454       if (skip_past_comma (&str) == FAIL
9455           || (offset = mav_parse_offset (&str, &negative), inst.error))
9456         goto fail_ldst;
9457
9458       inst.instruction |= CP_T_WB; /* Post indexed, set bit W.  */
9459     }
9460
9461   if (negative)
9462     offset = -offset;
9463   else
9464     inst.instruction |= CP_T_UD; /* Postive, so set bit U.  */
9465
9466   inst.instruction |= offset >> 2;
9467   end_of_line (str);
9468   return;
9469
9470 fail_ldst:
9471   if (!inst.error)
9472      inst.error = BAD_ARGS;
9473   return;
9474 }
9475
9476 static void
9477 do_t_nop (str)
9478      char * str;
9479 {
9480   /* Do nothing.  */
9481   end_of_line (str);
9482   return;
9483 }
9484
9485 /* Handle the Format 4 instructions that do not have equivalents in other
9486    formats.  That is, ADC, AND, EOR, SBC, ROR, TST, NEG, CMN, ORR, MUL,
9487    BIC and MVN.  */
9488
9489 static void
9490 do_t_arit (str)
9491      char * str;
9492 {
9493   int Rd, Rs, Rn;
9494
9495   skip_whitespace (str);
9496
9497   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
9498       || skip_past_comma (&str) == FAIL
9499       || (Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
9500     {
9501       inst.error = BAD_ARGS;
9502       return;
9503     }
9504
9505   if (skip_past_comma (&str) != FAIL)
9506     {
9507       /* Three operand format not allowed for TST, CMN, NEG and MVN.
9508          (It isn't allowed for CMP either, but that isn't handled by this
9509          function.)  */
9510       if (inst.instruction == T_OPCODE_TST
9511           || inst.instruction == T_OPCODE_CMN
9512           || inst.instruction == T_OPCODE_NEG
9513           || inst.instruction == T_OPCODE_MVN)
9514         {
9515           inst.error = BAD_ARGS;
9516           return;
9517         }
9518
9519       if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
9520         return;
9521
9522       if (Rs != Rd)
9523         {
9524           inst.error = _("dest and source1 must be the same register");
9525           return;
9526         }
9527       Rs = Rn;
9528     }
9529
9530   if (inst.instruction == T_OPCODE_MUL
9531       && Rs == Rd)
9532     as_tsktsk (_("Rs and Rd must be different in MUL"));
9533
9534   inst.instruction |= Rd | (Rs << 3);
9535   end_of_line (str);
9536 }
9537
9538 static void
9539 do_t_add (str)
9540      char * str;
9541 {
9542   thumb_add_sub (str, 0);
9543 }
9544
9545 static void
9546 do_t_asr (str)
9547      char * str;
9548 {
9549   thumb_shift (str, THUMB_ASR);
9550 }
9551
9552 static void
9553 do_t_branch9 (str)
9554      char * str;
9555 {
9556   if (my_get_expression (&inst.reloc.exp, &str))
9557     return;
9558   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH9;
9559   inst.reloc.pc_rel = 1;
9560   end_of_line (str);
9561 }
9562
9563 static void
9564 do_t_branch12 (str)
9565      char * str;
9566 {
9567   if (my_get_expression (&inst.reloc.exp, &str))
9568     return;
9569   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH12;
9570   inst.reloc.pc_rel = 1;
9571   end_of_line (str);
9572 }
9573
9574 /* Find the real, Thumb encoded start of a Thumb function.  */
9575
9576 static symbolS *
9577 find_real_start (symbolP)
9578      symbolS * symbolP;
9579 {
9580   char *       real_start;
9581   const char * name = S_GET_NAME (symbolP);
9582   symbolS *    new_target;
9583
9584   /* This definiton must agree with the one in gcc/config/arm/thumb.c.  */
9585 #define STUB_NAME ".real_start_of"
9586
9587   if (name == NULL)
9588     abort ();
9589
9590   /* Names that start with '.' are local labels, not function entry points.
9591      The compiler may generate BL instructions to these labels because it
9592      needs to perform a branch to a far away location.  */
9593   if (name[0] == '.')
9594     return symbolP;
9595
9596   real_start = malloc (strlen (name) + strlen (STUB_NAME) + 1);
9597   sprintf (real_start, "%s%s", STUB_NAME, name);
9598
9599   new_target = symbol_find (real_start);
9600
9601   if (new_target == NULL)
9602     {
9603       as_warn ("Failed to find real start of function: %s\n", name);
9604       new_target = symbolP;
9605     }
9606
9607   free (real_start);
9608
9609   return new_target;
9610 }
9611
9612 static void
9613 do_t_branch23 (str)
9614      char * str;
9615 {
9616   if (my_get_expression (& inst.reloc.exp, & str))
9617     return;
9618
9619   inst.reloc.type   = BFD_RELOC_THUMB_PCREL_BRANCH23;
9620   inst.reloc.pc_rel = 1;
9621   end_of_line (str);
9622
9623   /* If the destination of the branch is a defined symbol which does not have
9624      the THUMB_FUNC attribute, then we must be calling a function which has
9625      the (interfacearm) attribute.  We look for the Thumb entry point to that
9626      function and change the branch to refer to that function instead.  */
9627   if (   inst.reloc.exp.X_op == O_symbol
9628       && inst.reloc.exp.X_add_symbol != NULL
9629       && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
9630       && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
9631     inst.reloc.exp.X_add_symbol =
9632       find_real_start (inst.reloc.exp.X_add_symbol);
9633 }
9634
9635 static void
9636 do_t_bx (str)
9637      char * str;
9638 {
9639   int reg;
9640
9641   skip_whitespace (str);
9642
9643   if ((reg = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
9644     return;
9645
9646   /* This sets THUMB_H2 from the top bit of reg.  */
9647   inst.instruction |= reg << 3;
9648
9649   /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC.  The reloc
9650      should cause the alignment to be checked once it is known.  This is
9651      because BX PC only works if the instruction is word aligned.  */
9652
9653   end_of_line (str);
9654 }
9655
9656 static void
9657 do_t_compare (str)
9658      char * str;
9659 {
9660   thumb_mov_compare (str, THUMB_COMPARE);
9661 }
9662
9663 static void
9664 do_t_ldmstm (str)
9665      char * str;
9666 {
9667   int Rb;
9668   long range;
9669
9670   skip_whitespace (str);
9671
9672   if ((Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
9673     return;
9674
9675   if (*str != '!')
9676     as_warn (_("inserted missing '!': load/store multiple always writes back base register"));
9677   else
9678     str++;
9679
9680   if (skip_past_comma (&str) == FAIL
9681       || (range = reg_list (&str)) == FAIL)
9682     {
9683       if (! inst.error)
9684         inst.error = BAD_ARGS;
9685       return;
9686     }
9687
9688   if (inst.reloc.type != BFD_RELOC_NONE)
9689     {
9690       /* This really doesn't seem worth it.  */
9691       inst.reloc.type = BFD_RELOC_NONE;
9692       inst.error = _("expression too complex");
9693       return;
9694     }
9695
9696   if (range & ~0xff)
9697     {
9698       inst.error = _("only lo-regs valid in load/store multiple");
9699       return;
9700     }
9701
9702   inst.instruction |= (Rb << 8) | range;
9703   end_of_line (str);
9704 }
9705
9706 static void
9707 do_t_ldr (str)
9708      char * str;
9709 {
9710   thumb_load_store (str, THUMB_LOAD, THUMB_WORD);
9711 }
9712
9713 static void
9714 do_t_ldrb (str)
9715      char * str;
9716 {
9717   thumb_load_store (str, THUMB_LOAD, THUMB_BYTE);
9718 }
9719
9720 static void
9721 do_t_ldrh (str)
9722      char * str;
9723 {
9724   thumb_load_store (str, THUMB_LOAD, THUMB_HALFWORD);
9725 }
9726
9727 static void
9728 do_t_lds (str)
9729      char * str;
9730 {
9731   int Rd, Rb, Ro;
9732
9733   skip_whitespace (str);
9734
9735   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
9736       || skip_past_comma (&str) == FAIL
9737       || *str++ != '['
9738       || (Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL
9739       || skip_past_comma (&str) == FAIL
9740       || (Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL
9741       || *str++ != ']')
9742     {
9743       if (! inst.error)
9744         inst.error = _("syntax: ldrs[b] Rd, [Rb, Ro]");
9745       return;
9746     }
9747
9748   inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
9749   end_of_line (str);
9750 }
9751
9752 static void
9753 do_t_lsl (str)
9754      char * str;
9755 {
9756   thumb_shift (str, THUMB_LSL);
9757 }
9758
9759 static void
9760 do_t_lsr (str)
9761      char * str;
9762 {
9763   thumb_shift (str, THUMB_LSR);
9764 }
9765
9766 static void
9767 do_t_mov (str)
9768      char * str;
9769 {
9770   thumb_mov_compare (str, THUMB_MOVE);
9771 }
9772
9773 static void
9774 do_t_push_pop (str)
9775      char * str;
9776 {
9777   long range;
9778
9779   skip_whitespace (str);
9780
9781   if ((range = reg_list (&str)) == FAIL)
9782     {
9783       if (! inst.error)
9784         inst.error = BAD_ARGS;
9785       return;
9786     }
9787
9788   if (inst.reloc.type != BFD_RELOC_NONE)
9789     {
9790       /* This really doesn't seem worth it.  */
9791       inst.reloc.type = BFD_RELOC_NONE;
9792       inst.error = _("expression too complex");
9793       return;
9794     }
9795
9796   if (range & ~0xff)
9797     {
9798       if ((inst.instruction == T_OPCODE_PUSH
9799            && (range & ~0xff) == 1 << REG_LR)
9800           || (inst.instruction == T_OPCODE_POP
9801               && (range & ~0xff) == 1 << REG_PC))
9802         {
9803           inst.instruction |= THUMB_PP_PC_LR;
9804           range &= 0xff;
9805         }
9806       else
9807         {
9808           inst.error = _("invalid register list to push/pop instruction");
9809           return;
9810         }
9811     }
9812
9813   inst.instruction |= range;
9814   end_of_line (str);
9815 }
9816
9817 static void
9818 do_t_str (str)
9819      char * str;
9820 {
9821   thumb_load_store (str, THUMB_STORE, THUMB_WORD);
9822 }
9823
9824 static void
9825 do_t_strb (str)
9826      char * str;
9827 {
9828   thumb_load_store (str, THUMB_STORE, THUMB_BYTE);
9829 }
9830
9831 static void
9832 do_t_strh (str)
9833      char * str;
9834 {
9835   thumb_load_store (str, THUMB_STORE, THUMB_HALFWORD);
9836 }
9837
9838 static void
9839 do_t_sub (str)
9840      char * str;
9841 {
9842   thumb_add_sub (str, 1);
9843 }
9844
9845 static void
9846 do_t_swi (str)
9847      char * str;
9848 {
9849   skip_whitespace (str);
9850
9851   if (my_get_expression (&inst.reloc.exp, &str))
9852     return;
9853
9854   inst.reloc.type = BFD_RELOC_ARM_SWI;
9855   end_of_line (str);
9856   return;
9857 }
9858
9859 static void
9860 do_t_adr (str)
9861      char * str;
9862 {
9863   int reg;
9864
9865   /* This is a pseudo-op of the form "adr rd, label" to be converted
9866      into a relative address of the form "add rd, pc, #label-.-4".  */
9867   skip_whitespace (str);
9868
9869   /* Store Rd in temporary location inside instruction.  */
9870   if ((reg = reg_required_here (&str, 4)) == FAIL
9871       || (reg > 7)  /* For Thumb reg must be r0..r7.  */
9872       || skip_past_comma (&str) == FAIL
9873       || my_get_expression (&inst.reloc.exp, &str))
9874     {
9875       if (!inst.error)
9876         inst.error = BAD_ARGS;
9877       return;
9878     }
9879
9880   inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
9881   inst.reloc.exp.X_add_number -= 4; /* PC relative adjust.  */
9882   inst.reloc.pc_rel = 1;
9883   inst.instruction |= REG_PC; /* Rd is already placed into the instruction.  */
9884
9885   end_of_line (str);
9886 }
9887
9888 static void
9889 insert_reg (r, htab)
9890      const struct reg_entry *r;
9891      struct hash_control *htab;
9892 {
9893   int    len  = strlen (r->name) + 2;
9894   char * buf  = (char *) xmalloc (len);
9895   char * buf2 = (char *) xmalloc (len);
9896   int    i    = 0;
9897
9898 #ifdef REGISTER_PREFIX
9899   buf[i++] = REGISTER_PREFIX;
9900 #endif
9901
9902   strcpy (buf + i, r->name);
9903
9904   for (i = 0; buf[i]; i++)
9905     buf2[i] = TOUPPER (buf[i]);
9906
9907   buf2[i] = '\0';
9908
9909   hash_insert (htab, buf,  (PTR) r);
9910   hash_insert (htab, buf2, (PTR) r);
9911 }
9912
9913 static void
9914 build_reg_hsh (map)
9915      struct reg_map *map;
9916 {
9917   const struct reg_entry *r;
9918
9919   if ((map->htab = hash_new ()) == NULL)
9920     as_fatal (_("virtual memory exhausted"));
9921
9922   for (r = map->names; r->name != NULL; r++)
9923     insert_reg (r, map->htab);
9924 }
9925
9926 static void
9927 insert_reg_alias (str, regnum, htab)
9928      char *str;
9929      int regnum;
9930      struct hash_control *htab;
9931 {
9932   struct reg_entry *new =
9933     (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
9934   char *name = xmalloc (strlen (str) + 1);
9935   strcpy (name, str);
9936
9937   new->name = name;
9938   new->number = regnum;
9939
9940   hash_insert (htab, name, (PTR) new);
9941 }
9942
9943 /* Look for the .req directive.  This is of the form:
9944
9945         newname .req existing_name
9946
9947    If we find one, or if it looks sufficiently like one that we want to
9948    handle any error here, return non-zero.  Otherwise return zero.  */
9949 static int
9950 create_register_alias (newname, p)
9951      char *newname;
9952      char *p;
9953 {
9954   char *q;
9955   char c;
9956
9957   q = p;
9958   skip_whitespace (q);
9959
9960   c = *p;
9961   *p = '\0';
9962
9963   if (*q && !strncmp (q, ".req ", 5))
9964     {
9965       char *copy_of_str;
9966       char *r;
9967
9968 #ifdef IGNORE_OPCODE_CASE
9969       newname = original_case_string;
9970 #endif
9971       copy_of_str = newname;
9972
9973       q += 4;
9974       skip_whitespace (q);
9975
9976       for (r = q; *r != '\0'; r++)
9977         if (*r == ' ')
9978           break;
9979
9980       if (r != q)
9981         {
9982           enum arm_reg_type new_type, old_type;
9983           int old_regno;
9984           char d = *r;
9985
9986           *r = '\0';
9987           old_type = arm_reg_parse_any (q);
9988           *r = d;
9989
9990           new_type = arm_reg_parse_any (newname);
9991
9992           if (new_type == REG_TYPE_MAX)
9993             {
9994               if (old_type != REG_TYPE_MAX)
9995                 {
9996                   old_regno = arm_reg_parse (&q, all_reg_maps[old_type].htab);
9997                   insert_reg_alias (newname, old_regno,
9998                                     all_reg_maps[old_type].htab);
9999                 }
10000               else
10001                 as_warn (_("register '%s' does not exist\n"), q);
10002             }
10003           else if (old_type == REG_TYPE_MAX)
10004             {
10005               as_warn (_("ignoring redefinition of register alias '%s' to non-existant register '%s'"),
10006                        copy_of_str, q);
10007             }
10008           else
10009             {
10010               /* Do not warn about redefinitions to the same alias.  */
10011               if (new_type != old_type
10012                   || (arm_reg_parse (&q, all_reg_maps[old_type].htab)
10013                       != arm_reg_parse (&q, all_reg_maps[new_type].htab)))
10014                 as_warn (_("ignoring redefinition of register alias '%s'"),
10015                          copy_of_str);
10016
10017             }
10018         }
10019       else
10020         as_warn (_("ignoring incomplete .req pseuso op"));
10021
10022       *p = c;
10023       return 1;
10024     }
10025   *p = c;
10026   return 0;
10027 }
10028
10029 static void
10030 set_constant_flonums ()
10031 {
10032   int i;
10033
10034   for (i = 0; i < NUM_FLOAT_VALS; i++)
10035     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
10036       abort ();
10037 }
10038
10039 /* Iterate over the base tables to create the instruction patterns.  */
10040 static void
10041 build_arm_ops_hsh ()
10042 {
10043   unsigned int i;
10044   unsigned int j;
10045   static struct obstack insn_obstack;
10046
10047   obstack_begin (&insn_obstack, 4000);
10048
10049   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
10050     {
10051       const struct asm_opcode *insn = insns + i;
10052
10053       if (insn->cond_offset != 0)
10054         {
10055           /* Insn supports conditional execution.  Build the varaints
10056              and insert them in the hash table.  */
10057           for (j = 0; j < sizeof (conds) / sizeof (struct asm_cond); j++)
10058             {
10059               unsigned len = strlen (insn->template);
10060               struct asm_opcode *new;
10061               char *template;
10062
10063               new = obstack_alloc (&insn_obstack, sizeof (struct asm_opcode));
10064               /* All condition codes are two characters.  */
10065               template = obstack_alloc (&insn_obstack, len + 3);
10066
10067               strncpy (template, insn->template, insn->cond_offset);
10068               strcpy (template + insn->cond_offset, conds[j].template);
10069               if (len > insn->cond_offset)
10070                 strcpy (template + insn->cond_offset + 2,
10071                         insn->template + insn->cond_offset);
10072               new->template = template;
10073               new->cond_offset = 0;
10074               new->variant = insn->variant;
10075               new->parms = insn->parms;
10076               new->value = (insn->value & ~COND_MASK) | conds[j].value;
10077
10078               hash_insert (arm_ops_hsh, new->template, (PTR) new);
10079             }
10080         }
10081       /* Finally, insert the unconditional insn in the table directly;
10082          no need to build a copy.  */
10083       hash_insert (arm_ops_hsh, insn->template, (PTR) insn);
10084     }
10085 }
10086
10087 #if defined OBJ_ELF || defined OBJ_COFF
10088
10089 #ifdef OBJ_ELF
10090 #define arm_Note Elf_External_Note
10091 #else
10092 typedef struct
10093 {
10094   unsigned char namesz[4];      /* Size of entry's owner string.  */
10095   unsigned char descsz[4];      /* Size of the note descriptor.  */
10096   unsigned char type[4];        /* Interpretation of the descriptor.  */
10097   char          name[1];        /* Start of the name+desc data.  */
10098 } arm_Note;
10099 #endif
10100
10101 /* The description is kept to a fix sized in order to make updating
10102    it and merging it easier.  */
10103 #define ARM_NOTE_DESCRIPTION_LENGTH     8
10104
10105 static void
10106 arm_add_note (name, description, type)
10107      const char * name;
10108      const char * description;
10109      unsigned int type;
10110 {
10111   arm_Note     note ATTRIBUTE_UNUSED;
10112   char *       p;
10113   unsigned int name_len;
10114
10115   name_len = (strlen (name) + 1 + 3) & ~3;
10116
10117   p = frag_more (sizeof (note.namesz));
10118   md_number_to_chars (p, (valueT) name_len, sizeof (note.namesz));
10119
10120   p = frag_more (sizeof (note.descsz));
10121   md_number_to_chars (p, (valueT) ARM_NOTE_DESCRIPTION_LENGTH, sizeof (note.descsz));
10122
10123   p = frag_more (sizeof (note.type));
10124   md_number_to_chars (p, (valueT) type, sizeof (note.type));
10125
10126   p = frag_more (name_len);
10127   strcpy (p, name);
10128
10129   p = frag_more (ARM_NOTE_DESCRIPTION_LENGTH);
10130   strncpy (p, description, ARM_NOTE_DESCRIPTION_LENGTH);
10131   frag_align (2, 0, 0);
10132 }
10133 #endif
10134
10135 void
10136 md_begin ()
10137 {
10138   unsigned mach;
10139   unsigned int i;
10140
10141   if (   (arm_ops_hsh = hash_new ()) == NULL
10142       || (arm_tops_hsh = hash_new ()) == NULL
10143       || (arm_cond_hsh = hash_new ()) == NULL
10144       || (arm_shift_hsh = hash_new ()) == NULL
10145       || (arm_psr_hsh = hash_new ()) == NULL)
10146     as_fatal (_("virtual memory exhausted"));
10147
10148   build_arm_ops_hsh ();
10149   for (i = 0; i < sizeof (tinsns) / sizeof (struct thumb_opcode); i++)
10150     hash_insert (arm_tops_hsh, tinsns[i].template, (PTR) (tinsns + i));
10151   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
10152     hash_insert (arm_cond_hsh, conds[i].template, (PTR) (conds + i));
10153   for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
10154     hash_insert (arm_shift_hsh, shift_names[i].name, (PTR) (shift_names + i));
10155   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
10156     hash_insert (arm_psr_hsh, psrs[i].template, (PTR) (psrs + i));
10157
10158   for (i = (int) REG_TYPE_FIRST; i < (int) REG_TYPE_MAX; i++)
10159     build_reg_hsh (all_reg_maps + i);
10160
10161   set_constant_flonums ();
10162
10163   /* Set the cpu variant based on the command-line options.  We prefer
10164      -mcpu= over -march= if both are set (as for GCC); and we prefer
10165      -mfpu= over any other way of setting the floating point unit.
10166      Use of legacy options with new options are faulted.  */
10167   if (legacy_cpu != -1)
10168     {
10169       if (mcpu_cpu_opt != -1 || march_cpu_opt != -1)
10170         as_bad (_("use of old and new-style options to set CPU type"));
10171
10172       mcpu_cpu_opt = legacy_cpu;
10173     }
10174   else if (mcpu_cpu_opt == -1)
10175     mcpu_cpu_opt = march_cpu_opt;
10176
10177   if (legacy_fpu != -1)
10178     {
10179       if (mfpu_opt != -1)
10180         as_bad (_("use of old and new-style options to set FPU type"));
10181
10182       mfpu_opt = legacy_fpu;
10183     }
10184   else if (mfpu_opt == -1)
10185     {
10186       if (mcpu_fpu_opt != -1)
10187         mfpu_opt = mcpu_fpu_opt;
10188       else
10189         mfpu_opt = march_fpu_opt;
10190     }
10191
10192   if (mfpu_opt == -1)
10193     {
10194       if (mcpu_cpu_opt == -1)
10195         mfpu_opt = FPU_DEFAULT;
10196       else if (mcpu_cpu_opt & ARM_EXT_V5)
10197         mfpu_opt = FPU_ARCH_VFP_V2;
10198       else
10199         mfpu_opt = FPU_ARCH_FPA;
10200     }
10201
10202   if (mcpu_cpu_opt == -1)
10203     mcpu_cpu_opt = CPU_DEFAULT;
10204
10205   cpu_variant = mcpu_cpu_opt | mfpu_opt;
10206
10207 #if defined OBJ_COFF || defined OBJ_ELF
10208   {
10209     unsigned int flags = 0;
10210
10211     /* Set the flags in the private structure.  */
10212     if (uses_apcs_26)      flags |= F_APCS26;
10213     if (support_interwork) flags |= F_INTERWORK;
10214     if (uses_apcs_float)   flags |= F_APCS_FLOAT;
10215     if (pic_code)          flags |= F_PIC;
10216     if ((cpu_variant & FPU_ANY) == FPU_NONE
10217         || (cpu_variant & FPU_ANY) == FPU_ARCH_VFP) /* VFP layout only.  */
10218       flags |= F_SOFT_FLOAT;
10219     /* Using VFP conventions (even if soft-float).  */
10220     if (cpu_variant & FPU_VFP_EXT_NONE) flags |= F_VFP_FLOAT;
10221
10222 #if defined OBJ_ELF
10223     if (cpu_variant & ARM_CEXT_MAVERICK)
10224       {
10225         flags ^= F_SOFT_FLOAT;
10226         flags |= EF_ARM_MAVERICK_FLOAT;
10227       }
10228 #endif
10229
10230     bfd_set_private_flags (stdoutput, flags);
10231
10232     /* We have run out flags in the COFF header to encode the
10233        status of ATPCS support, so instead we create a dummy,
10234        empty, debug section called .arm.atpcs.  */
10235     if (atpcs)
10236       {
10237         asection * sec;
10238
10239         sec = bfd_make_section (stdoutput, ".arm.atpcs");
10240
10241         if (sec != NULL)
10242           {
10243             bfd_set_section_flags
10244               (stdoutput, sec, SEC_READONLY | SEC_DEBUGGING /* | SEC_HAS_CONTENTS */);
10245             bfd_set_section_size (stdoutput, sec, 0);
10246             bfd_set_section_contents (stdoutput, sec, NULL, 0, 0);
10247           }
10248       }
10249   }
10250 #endif
10251
10252   /* Record the CPU type as well.  */
10253   switch (cpu_variant & ARM_CPU_MASK)
10254     {
10255     case ARM_2:
10256       mach = bfd_mach_arm_2;
10257       break;
10258
10259     case ARM_3:                 /* Also ARM_250.  */
10260       mach = bfd_mach_arm_2a;
10261       break;
10262
10263     case ARM_6:                 /* Also ARM_7.  */
10264       mach = bfd_mach_arm_3;
10265       break;
10266
10267     default:
10268       mach = bfd_mach_arm_unknown;
10269       break;
10270     }
10271
10272   /* Catch special cases.  */
10273   if (cpu_variant & ARM_CEXT_IWMMXT)
10274     mach = bfd_mach_arm_iWMMXt;
10275   else if (cpu_variant & ARM_CEXT_XSCALE)
10276     mach = bfd_mach_arm_XScale;
10277   else if (cpu_variant & ARM_CEXT_MAVERICK)
10278     mach = bfd_mach_arm_ep9312;
10279   else if (cpu_variant & ARM_EXT_V5E)
10280     mach = bfd_mach_arm_5TE;
10281   else if (cpu_variant & ARM_EXT_V5)
10282     {
10283       if (cpu_variant & ARM_EXT_V4T)
10284         mach = bfd_mach_arm_5T;
10285       else
10286         mach = bfd_mach_arm_5;
10287     }
10288   else if (cpu_variant & ARM_EXT_V4)
10289     {
10290       if (cpu_variant & ARM_EXT_V4T)
10291         mach = bfd_mach_arm_4T;
10292       else
10293         mach = bfd_mach_arm_4;
10294     }
10295   else if (cpu_variant & ARM_EXT_V3M)
10296     mach = bfd_mach_arm_3M;
10297
10298 #if 0 /* Suppressed - for now.  */
10299 #if defined (OBJ_ELF) || defined (OBJ_COFF)
10300
10301   /* Create a .note section to fully identify this arm binary.  */
10302
10303 #define NOTE_ARCH_STRING        "arch: "
10304
10305 #if defined OBJ_COFF && ! defined NT_VERSION
10306 #define NT_VERSION  1
10307 #define NT_ARCH     2
10308 #endif
10309
10310   {
10311     segT current_seg = now_seg;
10312     subsegT current_subseg = now_subseg;
10313     asection * arm_arch;
10314     const char * arch_string;
10315
10316     arm_arch = bfd_make_section_old_way (stdoutput, ARM_NOTE_SECTION);
10317
10318 #ifdef OBJ_COFF
10319     bfd_set_section_flags (stdoutput, arm_arch,
10320                            SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_LINK_ONCE \
10321                            | SEC_HAS_CONTENTS);
10322 #endif
10323     arm_arch->output_section = arm_arch;
10324     subseg_set (arm_arch, 0);
10325
10326     switch (mach)
10327       {
10328       default:
10329       case bfd_mach_arm_unknown: arch_string = "unknown"; break;
10330       case bfd_mach_arm_2:       arch_string = "armv2"; break;
10331       case bfd_mach_arm_2a:      arch_string = "armv2a"; break;
10332       case bfd_mach_arm_3:       arch_string = "armv3"; break;
10333       case bfd_mach_arm_3M:      arch_string = "armv3M"; break;
10334       case bfd_mach_arm_4:       arch_string = "armv4"; break;
10335       case bfd_mach_arm_4T:      arch_string = "armv4t"; break;
10336       case bfd_mach_arm_5:       arch_string = "armv5"; break;
10337       case bfd_mach_arm_5T:      arch_string = "armv5t"; break;
10338       case bfd_mach_arm_5TE:     arch_string = "armv5te"; break;
10339       case bfd_mach_arm_XScale:  arch_string = "XScale"; break;
10340       case bfd_mach_arm_ep9312:  arch_string = "ep9312"; break;
10341       case bfd_mach_arm_iWMMXt:  arch_string = "iWMMXt"; break;
10342       }
10343
10344     arm_add_note (NOTE_ARCH_STRING, arch_string, NT_ARCH);
10345
10346     subseg_set (current_seg, current_subseg);
10347   }
10348 #endif
10349 #endif /* Suppressed code.  */
10350
10351   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
10352 }
10353
10354 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
10355    for use in the a.out file, and stores them in the array pointed to by buf.
10356    This knows about the endian-ness of the target machine and does
10357    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
10358    2 (short) and 4 (long)  Floating numbers are put out as a series of
10359    LITTLENUMS (shorts, here at least).  */
10360
10361 void
10362 md_number_to_chars (buf, val, n)
10363      char * buf;
10364      valueT val;
10365      int    n;
10366 {
10367   if (target_big_endian)
10368     number_to_chars_bigendian (buf, val, n);
10369   else
10370     number_to_chars_littleendian (buf, val, n);
10371 }
10372
10373 static valueT
10374 md_chars_to_number (buf, n)
10375      char * buf;
10376      int    n;
10377 {
10378   valueT result = 0;
10379   unsigned char * where = (unsigned char *) buf;
10380
10381   if (target_big_endian)
10382     {
10383       while (n--)
10384         {
10385           result <<= 8;
10386           result |= (*where++ & 255);
10387         }
10388     }
10389   else
10390     {
10391       while (n--)
10392         {
10393           result <<= 8;
10394           result |= (where[n] & 255);
10395         }
10396     }
10397
10398   return result;
10399 }
10400
10401 /* Turn a string in input_line_pointer into a floating point constant
10402    of type TYPE, and store the appropriate bytes in *LITP.  The number
10403    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
10404    returned, or NULL on OK.
10405
10406    Note that fp constants aren't represent in the normal way on the ARM.
10407    In big endian mode, things are as expected.  However, in little endian
10408    mode fp constants are big-endian word-wise, and little-endian byte-wise
10409    within the words.  For example, (double) 1.1 in big endian mode is
10410    the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
10411    the byte sequence 99 99 f1 3f 9a 99 99 99.
10412
10413    ??? The format of 12 byte floats is uncertain according to gcc's arm.h.  */
10414
10415 char *
10416 md_atof (type, litP, sizeP)
10417      char   type;
10418      char * litP;
10419      int *  sizeP;
10420 {
10421   int prec;
10422   LITTLENUM_TYPE words[MAX_LITTLENUMS];
10423   char *t;
10424   int i;
10425
10426   switch (type)
10427     {
10428     case 'f':
10429     case 'F':
10430     case 's':
10431     case 'S':
10432       prec = 2;
10433       break;
10434
10435     case 'd':
10436     case 'D':
10437     case 'r':
10438     case 'R':
10439       prec = 4;
10440       break;
10441
10442     case 'x':
10443     case 'X':
10444       prec = 6;
10445       break;
10446
10447     case 'p':
10448     case 'P':
10449       prec = 6;
10450       break;
10451
10452     default:
10453       *sizeP = 0;
10454       return _("bad call to MD_ATOF()");
10455     }
10456
10457   t = atof_ieee (input_line_pointer, type, words);
10458   if (t)
10459     input_line_pointer = t;
10460   *sizeP = prec * 2;
10461
10462   if (target_big_endian)
10463     {
10464       for (i = 0; i < prec; i++)
10465         {
10466           md_number_to_chars (litP, (valueT) words[i], 2);
10467           litP += 2;
10468         }
10469     }
10470   else
10471     {
10472       if (cpu_variant & FPU_ARCH_VFP)
10473         for (i = prec - 1; i >= 0; i--)
10474           {
10475             md_number_to_chars (litP, (valueT) words[i], 2);
10476             litP += 2;
10477           }
10478       else
10479         /* For a 4 byte float the order of elements in `words' is 1 0.
10480            For an 8 byte float the order is 1 0 3 2.  */
10481         for (i = 0; i < prec; i += 2)
10482           {
10483             md_number_to_chars (litP, (valueT) words[i + 1], 2);
10484             md_number_to_chars (litP + 2, (valueT) words[i], 2);
10485             litP += 4;
10486           }
10487     }
10488
10489   return 0;
10490 }
10491
10492 /* The knowledge of the PC's pipeline offset is built into the insns
10493    themselves.  */
10494
10495 long
10496 md_pcrel_from (fixP)
10497      fixS * fixP;
10498 {
10499   if (fixP->fx_addsy
10500       && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section
10501       && fixP->fx_subsy == NULL)
10502     return 0;
10503
10504   if (fixP->fx_pcrel && (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_ADD))
10505     {
10506       /* PC relative addressing on the Thumb is slightly odd
10507          as the bottom two bits of the PC are forced to zero
10508          for the calculation.  */
10509       return (fixP->fx_where + fixP->fx_frag->fr_address) & ~3;
10510     }
10511
10512 #ifdef TE_WINCE
10513   /* The pattern was adjusted to accomodate CE's off-by-one fixups,
10514      so we un-adjust here to compensate for the accomodation.  */
10515   return fixP->fx_where + fixP->fx_frag->fr_address + 8;
10516 #else
10517   return fixP->fx_where + fixP->fx_frag->fr_address;
10518 #endif
10519 }
10520
10521 /* Round up a section size to the appropriate boundary.  */
10522
10523 valueT
10524 md_section_align (segment, size)
10525      segT   segment ATTRIBUTE_UNUSED;
10526      valueT size;
10527 {
10528 #ifdef OBJ_ELF
10529   return size;
10530 #else
10531   /* Round all sects to multiple of 4.  */
10532   return (size + 3) & ~3;
10533 #endif
10534 }
10535
10536 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
10537    Otherwise we have no need to default values of symbols.  */
10538
10539 symbolS *
10540 md_undefined_symbol (name)
10541      char * name ATTRIBUTE_UNUSED;
10542 {
10543 #ifdef OBJ_ELF
10544   if (name[0] == '_' && name[1] == 'G'
10545       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
10546     {
10547       if (!GOT_symbol)
10548         {
10549           if (symbol_find (name))
10550             as_bad ("GOT already in the symbol table");
10551
10552           GOT_symbol = symbol_new (name, undefined_section,
10553                                    (valueT) 0, & zero_address_frag);
10554         }
10555
10556       return GOT_symbol;
10557     }
10558 #endif
10559
10560   return 0;
10561 }
10562
10563 /* arm_reg_parse () := if it looks like a register, return its token and
10564    advance the pointer.  */
10565
10566 static int
10567 arm_reg_parse (ccp, htab)
10568      register char ** ccp;
10569      struct hash_control *htab;
10570 {
10571   char * start = * ccp;
10572   char   c;
10573   char * p;
10574   struct reg_entry * reg;
10575
10576 #ifdef REGISTER_PREFIX
10577   if (*start != REGISTER_PREFIX)
10578     return FAIL;
10579   p = start + 1;
10580 #else
10581   p = start;
10582 #ifdef OPTIONAL_REGISTER_PREFIX
10583   if (*p == OPTIONAL_REGISTER_PREFIX)
10584     p++, start++;
10585 #endif
10586 #endif
10587   if (!ISALPHA (*p) || !is_name_beginner (*p))
10588     return FAIL;
10589
10590   c = *p++;
10591   while (ISALPHA (c) || ISDIGIT (c) || c == '_')
10592     c = *p++;
10593
10594   *--p = 0;
10595   reg = (struct reg_entry *) hash_find (htab, start);
10596   *p = c;
10597
10598   if (reg)
10599     {
10600       *ccp = p;
10601       return reg->number;
10602     }
10603
10604   return FAIL;
10605 }
10606
10607 /* Search for the following register name in each of the possible reg name
10608    tables.  Return the classification if found, or REG_TYPE_MAX if not
10609    present.  */
10610 static enum arm_reg_type
10611 arm_reg_parse_any (cp)
10612      char *cp;
10613 {
10614   int i;
10615
10616   for (i = (int) REG_TYPE_FIRST; i < (int) REG_TYPE_MAX; i++)
10617     if (arm_reg_parse (&cp, all_reg_maps[i].htab) != FAIL)
10618       return (enum arm_reg_type) i;
10619
10620   return REG_TYPE_MAX;
10621 }
10622
10623 void
10624 md_apply_fix3 (fixP, valP, seg)
10625      fixS *   fixP;
10626      valueT * valP;
10627      segT     seg;
10628 {
10629   offsetT        value = * valP;
10630   offsetT        newval;
10631   unsigned int   newimm;
10632   unsigned long  temp;
10633   int            sign;
10634   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
10635   arm_fix_data * arm_data = (arm_fix_data *) fixP->tc_fix_data;
10636
10637   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
10638
10639   /* Note whether this will delete the relocation.  */
10640 #if 0
10641   /* Patch from REarnshaw to JDavis (disabled for the moment, since it
10642      doesn't work fully.)  */
10643   if ((fixP->fx_addsy == 0 || symbol_constant_p (fixP->fx_addsy))
10644       && !fixP->fx_pcrel)
10645 #else
10646   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
10647 #endif
10648     fixP->fx_done = 1;
10649
10650   /* If this symbol is in a different section then we need to leave it for
10651      the linker to deal with.  Unfortunately, md_pcrel_from can't tell,
10652      so we have to undo it's effects here.  */
10653   if (fixP->fx_pcrel)
10654     {
10655       if (fixP->fx_addsy != NULL
10656           && S_IS_DEFINED (fixP->fx_addsy)
10657           && S_GET_SEGMENT (fixP->fx_addsy) != seg)
10658         {
10659           if (target_oabi
10660               && (fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
10661                   || fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
10662                   ))
10663             value = 0;
10664           else
10665             value += md_pcrel_from (fixP);
10666         }
10667     }
10668
10669   /* Remember value for emit_reloc.  */
10670   fixP->fx_addnumber = value;
10671
10672   switch (fixP->fx_r_type)
10673     {
10674     case BFD_RELOC_ARM_IMMEDIATE:
10675       newimm = validate_immediate (value);
10676       temp = md_chars_to_number (buf, INSN_SIZE);
10677
10678       /* If the instruction will fail, see if we can fix things up by
10679          changing the opcode.  */
10680       if (newimm == (unsigned int) FAIL
10681           && (newimm = negate_data_op (&temp, value)) == (unsigned int) FAIL)
10682         {
10683           as_bad_where (fixP->fx_file, fixP->fx_line,
10684                         _("invalid constant (%lx) after fixup"),
10685                         (unsigned long) value);
10686           break;
10687         }
10688
10689       newimm |= (temp & 0xfffff000);
10690       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
10691       fixP->fx_done = 1;
10692       break;
10693
10694     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
10695       {
10696         unsigned int highpart = 0;
10697         unsigned int newinsn  = 0xe1a00000; /* nop.  */
10698
10699         newimm = validate_immediate (value);
10700         temp = md_chars_to_number (buf, INSN_SIZE);
10701
10702         /* If the instruction will fail, see if we can fix things up by
10703            changing the opcode.  */
10704         if (newimm == (unsigned int) FAIL
10705             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
10706           {
10707             /* No ?  OK - try using two ADD instructions to generate
10708                the value.  */
10709             newimm = validate_immediate_twopart (value, & highpart);
10710
10711             /* Yes - then make sure that the second instruction is
10712                also an add.  */
10713             if (newimm != (unsigned int) FAIL)
10714               newinsn = temp;
10715             /* Still No ?  Try using a negated value.  */
10716             else if ((newimm = validate_immediate_twopart (- value, & highpart)) != (unsigned int) FAIL)
10717               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
10718             /* Otherwise - give up.  */
10719             else
10720               {
10721                 as_bad_where (fixP->fx_file, fixP->fx_line,
10722                               _("unable to compute ADRL instructions for PC offset of 0x%lx"),
10723                               (long) value);
10724                 break;
10725               }
10726
10727             /* Replace the first operand in the 2nd instruction (which
10728                is the PC) with the destination register.  We have
10729                already added in the PC in the first instruction and we
10730                do not want to do it again.  */
10731             newinsn &= ~ 0xf0000;
10732             newinsn |= ((newinsn & 0x0f000) << 4);
10733           }
10734
10735         newimm |= (temp & 0xfffff000);
10736         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
10737
10738         highpart |= (newinsn & 0xfffff000);
10739         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
10740       }
10741       break;
10742
10743     case BFD_RELOC_ARM_OFFSET_IMM:
10744       sign = value >= 0;
10745
10746       if (value < 0)
10747         value = - value;
10748
10749       if (validate_offset_imm (value, 0) == FAIL)
10750         {
10751           as_bad_where (fixP->fx_file, fixP->fx_line,
10752                         _("bad immediate value for offset (%ld)"),
10753                         (long) value);
10754           break;
10755         }
10756
10757       newval = md_chars_to_number (buf, INSN_SIZE);
10758       newval &= 0xff7ff000;
10759       newval |= value | (sign ? INDEX_UP : 0);
10760       md_number_to_chars (buf, newval, INSN_SIZE);
10761       break;
10762
10763     case BFD_RELOC_ARM_OFFSET_IMM8:
10764     case BFD_RELOC_ARM_HWLITERAL:
10765       sign = value >= 0;
10766
10767       if (value < 0)
10768         value = - value;
10769
10770       if (validate_offset_imm (value, 1) == FAIL)
10771         {
10772           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
10773             as_bad_where (fixP->fx_file, fixP->fx_line,
10774                           _("invalid literal constant: pool needs to be closer"));
10775           else
10776             as_bad (_("bad immediate value for half-word offset (%ld)"),
10777                     (long) value);
10778           break;
10779         }
10780
10781       newval = md_chars_to_number (buf, INSN_SIZE);
10782       newval &= 0xff7ff0f0;
10783       newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
10784       md_number_to_chars (buf, newval, INSN_SIZE);
10785       break;
10786
10787     case BFD_RELOC_ARM_LITERAL:
10788       sign = value >= 0;
10789
10790       if (value < 0)
10791         value = - value;
10792
10793       if (validate_offset_imm (value, 0) == FAIL)
10794         {
10795           as_bad_where (fixP->fx_file, fixP->fx_line,
10796                         _("invalid literal constant: pool needs to be closer"));
10797           break;
10798         }
10799
10800       newval = md_chars_to_number (buf, INSN_SIZE);
10801       newval &= 0xff7ff000;
10802       newval |= value | (sign ? INDEX_UP : 0);
10803       md_number_to_chars (buf, newval, INSN_SIZE);
10804       break;
10805
10806     case BFD_RELOC_ARM_SHIFT_IMM:
10807       newval = md_chars_to_number (buf, INSN_SIZE);
10808       if (((unsigned long) value) > 32
10809           || (value == 32
10810               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
10811         {
10812           as_bad_where (fixP->fx_file, fixP->fx_line,
10813                         _("shift expression is too large"));
10814           break;
10815         }
10816
10817       if (value == 0)
10818         /* Shifts of zero must be done as lsl.  */
10819         newval &= ~0x60;
10820       else if (value == 32)
10821         value = 0;
10822       newval &= 0xfffff07f;
10823       newval |= (value & 0x1f) << 7;
10824       md_number_to_chars (buf, newval, INSN_SIZE);
10825       break;
10826
10827     case BFD_RELOC_ARM_SWI:
10828       if (arm_data->thumb_mode)
10829         {
10830           if (((unsigned long) value) > 0xff)
10831             as_bad_where (fixP->fx_file, fixP->fx_line,
10832                           _("invalid swi expression"));
10833           newval = md_chars_to_number (buf, THUMB_SIZE) & 0xff00;
10834           newval |= value;
10835           md_number_to_chars (buf, newval, THUMB_SIZE);
10836         }
10837       else
10838         {
10839           if (((unsigned long) value) > 0x00ffffff)
10840             as_bad_where (fixP->fx_file, fixP->fx_line,
10841                           _("invalid swi expression"));
10842           newval = md_chars_to_number (buf, INSN_SIZE) & 0xff000000;
10843           newval |= value;
10844           md_number_to_chars (buf, newval, INSN_SIZE);
10845         }
10846       break;
10847
10848     case BFD_RELOC_ARM_MULTI:
10849       if (((unsigned long) value) > 0xffff)
10850         as_bad_where (fixP->fx_file, fixP->fx_line,
10851                       _("invalid expression in load/store multiple"));
10852       newval = value | md_chars_to_number (buf, INSN_SIZE);
10853       md_number_to_chars (buf, newval, INSN_SIZE);
10854       break;
10855
10856     case BFD_RELOC_ARM_PCREL_BRANCH:
10857       newval = md_chars_to_number (buf, INSN_SIZE);
10858
10859       /* Sign-extend a 24-bit number.  */
10860 #define SEXT24(x)       ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
10861
10862 #ifdef OBJ_ELF
10863       if (! target_oabi)
10864         value = fixP->fx_offset;
10865 #endif
10866
10867       /* We are going to store value (shifted right by two) in the
10868          instruction, in a 24 bit, signed field.  Thus we need to check
10869          that none of the top 8 bits of the shifted value (top 7 bits of
10870          the unshifted, unsigned value) are set, or that they are all set.  */
10871       if ((value & ~ ((offsetT) 0x1ffffff)) != 0
10872           && ((value & ~ ((offsetT) 0x1ffffff)) != ~ ((offsetT) 0x1ffffff)))
10873         {
10874 #ifdef OBJ_ELF
10875           /* Normally we would be stuck at this point, since we cannot store
10876              the absolute address that is the destination of the branch in the
10877              24 bits of the branch instruction.  If however, we happen to know
10878              that the destination of the branch is in the same section as the
10879              branch instruciton itself, then we can compute the relocation for
10880              ourselves and not have to bother the linker with it.
10881
10882              FIXME: The tests for OBJ_ELF and ! target_oabi are only here
10883              because I have not worked out how to do this for OBJ_COFF or
10884              target_oabi.  */
10885           if (! target_oabi
10886               && fixP->fx_addsy != NULL
10887               && S_IS_DEFINED (fixP->fx_addsy)
10888               && S_GET_SEGMENT (fixP->fx_addsy) == seg)
10889             {
10890               /* Get pc relative value to go into the branch.  */
10891               value = * valP;
10892
10893               /* Permit a backward branch provided that enough bits
10894                  are set.  Allow a forwards branch, provided that
10895                  enough bits are clear.  */
10896               if (   (value & ~ ((offsetT) 0x1ffffff)) == ~ ((offsetT) 0x1ffffff)
10897                   || (value & ~ ((offsetT) 0x1ffffff)) == 0)
10898                 fixP->fx_done = 1;
10899             }
10900
10901           if (! fixP->fx_done)
10902 #endif
10903             as_bad_where (fixP->fx_file, fixP->fx_line,
10904                           _("GAS can't handle same-section branch dest >= 0x04000000"));
10905         }
10906
10907       value >>= 2;
10908       value += SEXT24 (newval);
10909
10910       if (    (value & ~ ((offsetT) 0xffffff)) != 0
10911           && ((value & ~ ((offsetT) 0xffffff)) != ~ ((offsetT) 0xffffff)))
10912         as_bad_where (fixP->fx_file, fixP->fx_line,
10913                       _("out of range branch"));
10914
10915       newval = (value & 0x00ffffff) | (newval & 0xff000000);
10916       md_number_to_chars (buf, newval, INSN_SIZE);
10917       break;
10918
10919     case BFD_RELOC_ARM_PCREL_BLX:
10920       {
10921         offsetT hbit;
10922         newval = md_chars_to_number (buf, INSN_SIZE);
10923
10924 #ifdef OBJ_ELF
10925         if (! target_oabi)
10926           value = fixP->fx_offset;
10927 #endif
10928         hbit   = (value >> 1) & 1;
10929         value  = (value >> 2) & 0x00ffffff;
10930         value  = (value + (newval & 0x00ffffff)) & 0x00ffffff;
10931         newval = value | (newval & 0xfe000000) | (hbit << 24);
10932         md_number_to_chars (buf, newval, INSN_SIZE);
10933       }
10934       break;
10935
10936     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
10937       newval = md_chars_to_number (buf, THUMB_SIZE);
10938       {
10939         addressT diff = (newval & 0xff) << 1;
10940         if (diff & 0x100)
10941           diff |= ~0xff;
10942
10943         value += diff;
10944         if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
10945           as_bad_where (fixP->fx_file, fixP->fx_line,
10946                         _("branch out of range"));
10947         newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
10948       }
10949       md_number_to_chars (buf, newval, THUMB_SIZE);
10950       break;
10951
10952     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
10953       newval = md_chars_to_number (buf, THUMB_SIZE);
10954       {
10955         addressT diff = (newval & 0x7ff) << 1;
10956         if (diff & 0x800)
10957           diff |= ~0x7ff;
10958
10959         value += diff;
10960         if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
10961           as_bad_where (fixP->fx_file, fixP->fx_line,
10962                         _("branch out of range"));
10963         newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
10964       }
10965       md_number_to_chars (buf, newval, THUMB_SIZE);
10966       break;
10967
10968     case BFD_RELOC_THUMB_PCREL_BLX:
10969     case BFD_RELOC_THUMB_PCREL_BRANCH23:
10970       {
10971         offsetT newval2;
10972         addressT diff;
10973
10974         newval  = md_chars_to_number (buf, THUMB_SIZE);
10975         newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
10976         diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
10977         if (diff & 0x400000)
10978           diff |= ~0x3fffff;
10979 #ifdef OBJ_ELF
10980         value = fixP->fx_offset;
10981 #endif
10982         value += diff;
10983
10984         if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
10985           as_bad_where (fixP->fx_file, fixP->fx_line,
10986                         _("branch with link out of range"));
10987
10988         newval  = (newval  & 0xf800) | ((value & 0x7fffff) >> 12);
10989         newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
10990         if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
10991           /* For a BLX instruction, make sure that the relocation is rounded up
10992              to a word boundary.  This follows the semantics of the instruction
10993              which specifies that bit 1 of the target address will come from bit
10994              1 of the base address.  */
10995           newval2 = (newval2 + 1) & ~ 1;
10996         md_number_to_chars (buf, newval, THUMB_SIZE);
10997         md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
10998       }
10999       break;
11000
11001     case BFD_RELOC_8:
11002       if (fixP->fx_done || fixP->fx_pcrel)
11003         md_number_to_chars (buf, value, 1);
11004 #ifdef OBJ_ELF
11005       else if (!target_oabi)
11006         {
11007           value = fixP->fx_offset;
11008           md_number_to_chars (buf, value, 1);
11009         }
11010 #endif
11011       break;
11012
11013     case BFD_RELOC_16:
11014       if (fixP->fx_done || fixP->fx_pcrel)
11015         md_number_to_chars (buf, value, 2);
11016 #ifdef OBJ_ELF
11017       else if (!target_oabi)
11018         {
11019           value = fixP->fx_offset;
11020           md_number_to_chars (buf, value, 2);
11021         }
11022 #endif
11023       break;
11024
11025 #ifdef OBJ_ELF
11026     case BFD_RELOC_ARM_GOT32:
11027     case BFD_RELOC_ARM_GOTOFF:
11028       md_number_to_chars (buf, 0, 4);
11029       break;
11030 #endif
11031
11032     case BFD_RELOC_RVA:
11033     case BFD_RELOC_32:
11034       if (fixP->fx_done || fixP->fx_pcrel)
11035         md_number_to_chars (buf, value, 4);
11036 #ifdef OBJ_ELF
11037       else if (!target_oabi)
11038         {
11039           value = fixP->fx_offset;
11040           md_number_to_chars (buf, value, 4);
11041         }
11042 #endif
11043       break;
11044
11045 #ifdef OBJ_ELF
11046     case BFD_RELOC_ARM_PLT32:
11047       /* It appears the instruction is fully prepared at this point.  */
11048       break;
11049 #endif
11050
11051     case BFD_RELOC_ARM_CP_OFF_IMM:
11052       sign = value >= 0;
11053       if (value < -1023 || value > 1023 || (value & 3))
11054         as_bad_where (fixP->fx_file, fixP->fx_line,
11055                       _("illegal value for co-processor offset"));
11056       if (value < 0)
11057         value = -value;
11058       newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
11059       newval |= (value >> 2) | (sign ? INDEX_UP : 0);
11060       md_number_to_chars (buf, newval, INSN_SIZE);
11061       break;
11062
11063     case BFD_RELOC_ARM_CP_OFF_IMM_S2:
11064       sign = value >= 0;
11065       if (value < -255 || value > 255)
11066         as_bad_where (fixP->fx_file, fixP->fx_line,
11067                       _("Illegal value for co-processor offset"));
11068       if (value < 0)
11069         value = -value;
11070       newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
11071       newval |= value | (sign ?  INDEX_UP : 0);
11072       md_number_to_chars (buf, newval , INSN_SIZE);
11073       break;
11074
11075     case BFD_RELOC_ARM_THUMB_OFFSET:
11076       newval = md_chars_to_number (buf, THUMB_SIZE);
11077       /* Exactly what ranges, and where the offset is inserted depends
11078          on the type of instruction, we can establish this from the
11079          top 4 bits.  */
11080       switch (newval >> 12)
11081         {
11082         case 4: /* PC load.  */
11083           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
11084              forced to zero for these loads, so we will need to round
11085              up the offset if the instruction address is not word
11086              aligned (since the final address produced must be, and
11087              we can only describe word-aligned immediate offsets).  */
11088
11089           if ((fixP->fx_frag->fr_address + fixP->fx_where + value) & 3)
11090             as_bad_where (fixP->fx_file, fixP->fx_line,
11091                           _("invalid offset, target not word aligned (0x%08X)"),
11092                           (unsigned int) (fixP->fx_frag->fr_address
11093                                           + fixP->fx_where + value));
11094
11095           if ((value + 2) & ~0x3fe)
11096             as_bad_where (fixP->fx_file, fixP->fx_line,
11097                           _("invalid offset, value too big (0x%08lX)"),
11098                           (long) value);
11099
11100           /* Round up, since pc will be rounded down.  */
11101           newval |= (value + 2) >> 2;
11102           break;
11103
11104         case 9: /* SP load/store.  */
11105           if (value & ~0x3fc)
11106             as_bad_where (fixP->fx_file, fixP->fx_line,
11107                           _("invalid offset, value too big (0x%08lX)"),
11108                           (long) value);
11109           newval |= value >> 2;
11110           break;
11111
11112         case 6: /* Word load/store.  */
11113           if (value & ~0x7c)
11114             as_bad_where (fixP->fx_file, fixP->fx_line,
11115                           _("invalid offset, value too big (0x%08lX)"),
11116                           (long) value);
11117           newval |= value << 4; /* 6 - 2.  */
11118           break;
11119
11120         case 7: /* Byte load/store.  */
11121           if (value & ~0x1f)
11122             as_bad_where (fixP->fx_file, fixP->fx_line,
11123                           _("invalid offset, value too big (0x%08lX)"),
11124                           (long) value);
11125           newval |= value << 6;
11126           break;
11127
11128         case 8: /* Halfword load/store.  */
11129           if (value & ~0x3e)
11130             as_bad_where (fixP->fx_file, fixP->fx_line,
11131                           _("invalid offset, value too big (0x%08lX)"),
11132                           (long) value);
11133           newval |= value << 5; /* 6 - 1.  */
11134           break;
11135
11136         default:
11137           as_bad_where (fixP->fx_file, fixP->fx_line,
11138                         "Unable to process relocation for thumb opcode: %lx",
11139                         (unsigned long) newval);
11140           break;
11141         }
11142       md_number_to_chars (buf, newval, THUMB_SIZE);
11143       break;
11144
11145     case BFD_RELOC_ARM_THUMB_ADD:
11146       /* This is a complicated relocation, since we use it for all of
11147          the following immediate relocations:
11148
11149             3bit ADD/SUB
11150             8bit ADD/SUB
11151             9bit ADD/SUB SP word-aligned
11152            10bit ADD PC/SP word-aligned
11153
11154          The type of instruction being processed is encoded in the
11155          instruction field:
11156
11157            0x8000  SUB
11158            0x00F0  Rd
11159            0x000F  Rs
11160       */
11161       newval = md_chars_to_number (buf, THUMB_SIZE);
11162       {
11163         int rd = (newval >> 4) & 0xf;
11164         int rs = newval & 0xf;
11165         int subtract = newval & 0x8000;
11166
11167         if (rd == REG_SP)
11168           {
11169             if (value & ~0x1fc)
11170               as_bad_where (fixP->fx_file, fixP->fx_line,
11171                             _("invalid immediate for stack address calculation"));
11172             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
11173             newval |= value >> 2;
11174           }
11175         else if (rs == REG_PC || rs == REG_SP)
11176           {
11177             if (subtract ||
11178                 value & ~0x3fc)
11179               as_bad_where (fixP->fx_file, fixP->fx_line,
11180                             _("invalid immediate for address calculation (value = 0x%08lX)"),
11181                             (unsigned long) value);
11182             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
11183             newval |= rd << 8;
11184             newval |= value >> 2;
11185           }
11186         else if (rs == rd)
11187           {
11188             if (value & ~0xff)
11189               as_bad_where (fixP->fx_file, fixP->fx_line,
11190                             _("invalid 8bit immediate"));
11191             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
11192             newval |= (rd << 8) | value;
11193           }
11194         else
11195           {
11196             if (value & ~0x7)
11197               as_bad_where (fixP->fx_file, fixP->fx_line,
11198                             _("invalid 3bit immediate"));
11199             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
11200             newval |= rd | (rs << 3) | (value << 6);
11201           }
11202       }
11203       md_number_to_chars (buf, newval, THUMB_SIZE);
11204       break;
11205
11206     case BFD_RELOC_ARM_THUMB_IMM:
11207       newval = md_chars_to_number (buf, THUMB_SIZE);
11208       switch (newval >> 11)
11209         {
11210         case 0x04: /* 8bit immediate MOV.  */
11211         case 0x05: /* 8bit immediate CMP.  */
11212           if (value < 0 || value > 255)
11213             as_bad_where (fixP->fx_file, fixP->fx_line,
11214                           _("invalid immediate: %ld is too large"),
11215                           (long) value);
11216           newval |= value;
11217           break;
11218
11219         default:
11220           abort ();
11221         }
11222       md_number_to_chars (buf, newval, THUMB_SIZE);
11223       break;
11224
11225     case BFD_RELOC_ARM_THUMB_SHIFT:
11226       /* 5bit shift value (0..31).  */
11227       if (value < 0 || value > 31)
11228         as_bad_where (fixP->fx_file, fixP->fx_line,
11229                       _("illegal Thumb shift value: %ld"), (long) value);
11230       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf03f;
11231       newval |= value << 6;
11232       md_number_to_chars (buf, newval, THUMB_SIZE);
11233       break;
11234
11235     case BFD_RELOC_VTABLE_INHERIT:
11236     case BFD_RELOC_VTABLE_ENTRY:
11237       fixP->fx_done = 0;
11238       return;
11239
11240     case BFD_RELOC_NONE:
11241     default:
11242       as_bad_where (fixP->fx_file, fixP->fx_line,
11243                     _("bad relocation fixup type (%d)"), fixP->fx_r_type);
11244     }
11245 }
11246
11247 /* Translate internal representation of relocation info to BFD target
11248    format.  */
11249
11250 arelent *
11251 tc_gen_reloc (section, fixp)
11252      asection * section ATTRIBUTE_UNUSED;
11253      fixS * fixp;
11254 {
11255   arelent * reloc;
11256   bfd_reloc_code_real_type code;
11257
11258   reloc = (arelent *) xmalloc (sizeof (arelent));
11259
11260   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
11261   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
11262   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
11263
11264   /* @@ Why fx_addnumber sometimes and fx_offset other times?  */
11265 #ifndef OBJ_ELF
11266   if (fixp->fx_pcrel == 0)
11267     reloc->addend = fixp->fx_offset;
11268   else
11269     reloc->addend = fixp->fx_offset = reloc->address;
11270 #else  /* OBJ_ELF */
11271   reloc->addend = fixp->fx_offset;
11272 #endif
11273
11274   switch (fixp->fx_r_type)
11275     {
11276     case BFD_RELOC_8:
11277       if (fixp->fx_pcrel)
11278         {
11279           code = BFD_RELOC_8_PCREL;
11280           break;
11281         }
11282
11283     case BFD_RELOC_16:
11284       if (fixp->fx_pcrel)
11285         {
11286           code = BFD_RELOC_16_PCREL;
11287           break;
11288         }
11289
11290     case BFD_RELOC_32:
11291       if (fixp->fx_pcrel)
11292         {
11293           code = BFD_RELOC_32_PCREL;
11294           break;
11295         }
11296
11297     case BFD_RELOC_ARM_PCREL_BRANCH:
11298     case BFD_RELOC_ARM_PCREL_BLX:
11299     case BFD_RELOC_RVA:
11300     case BFD_RELOC_THUMB_PCREL_BRANCH9:
11301     case BFD_RELOC_THUMB_PCREL_BRANCH12:
11302     case BFD_RELOC_THUMB_PCREL_BRANCH23:
11303     case BFD_RELOC_THUMB_PCREL_BLX:
11304     case BFD_RELOC_VTABLE_ENTRY:
11305     case BFD_RELOC_VTABLE_INHERIT:
11306       code = fixp->fx_r_type;
11307       break;
11308
11309     case BFD_RELOC_ARM_LITERAL:
11310     case BFD_RELOC_ARM_HWLITERAL:
11311       /* If this is called then the a literal has
11312          been referenced across a section boundary.  */
11313       as_bad_where (fixp->fx_file, fixp->fx_line,
11314                     _("literal referenced across section boundary"));
11315       return NULL;
11316
11317 #ifdef OBJ_ELF
11318     case BFD_RELOC_ARM_GOT32:
11319     case BFD_RELOC_ARM_GOTOFF:
11320     case BFD_RELOC_ARM_PLT32:
11321       code = fixp->fx_r_type;
11322       break;
11323 #endif
11324
11325     case BFD_RELOC_ARM_IMMEDIATE:
11326       as_bad_where (fixp->fx_file, fixp->fx_line,
11327                     _("internal relocation (type: IMMEDIATE) not fixed up"));
11328       return NULL;
11329
11330     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
11331       as_bad_where (fixp->fx_file, fixp->fx_line,
11332                     _("ADRL used for a symbol not defined in the same file"));
11333       return NULL;
11334
11335     case BFD_RELOC_ARM_OFFSET_IMM:
11336       as_bad_where (fixp->fx_file, fixp->fx_line,
11337                     _("internal_relocation (type: OFFSET_IMM) not fixed up"));
11338       return NULL;
11339
11340     default:
11341       {
11342         char * type;
11343
11344         switch (fixp->fx_r_type)
11345           {
11346           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
11347           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
11348           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
11349           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
11350           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
11351           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
11352           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
11353           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
11354           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
11355           default:                         type = _("<unknown>"); break;
11356           }
11357         as_bad_where (fixp->fx_file, fixp->fx_line,
11358                       _("cannot represent %s relocation in this object file format"),
11359                       type);
11360         return NULL;
11361       }
11362     }
11363
11364 #ifdef OBJ_ELF
11365   if ((code == BFD_RELOC_32_PCREL || code == BFD_RELOC_32)
11366       && GOT_symbol
11367       && fixp->fx_addsy == GOT_symbol)
11368     {
11369       code = BFD_RELOC_ARM_GOTPC;
11370       reloc->addend = fixp->fx_offset = reloc->address;
11371     }
11372 #endif
11373
11374   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
11375
11376   if (reloc->howto == NULL)
11377     {
11378       as_bad_where (fixp->fx_file, fixp->fx_line,
11379                     _("cannot represent %s relocation in this object file format"),
11380                     bfd_get_reloc_code_name (code));
11381       return NULL;
11382     }
11383
11384   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
11385      vtable entry to be used in the relocation's section offset.  */
11386   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
11387     reloc->address = fixp->fx_offset;
11388
11389   return reloc;
11390 }
11391
11392 int
11393 md_estimate_size_before_relax (fragP, segtype)
11394      fragS * fragP ATTRIBUTE_UNUSED;
11395      segT    segtype ATTRIBUTE_UNUSED;
11396 {
11397   as_fatal (_("md_estimate_size_before_relax\n"));
11398   return 1;
11399 }
11400
11401 static void
11402 output_inst (str)
11403      const char *str;
11404 {
11405   char * to = NULL;
11406
11407   if (inst.error)
11408     {
11409       as_bad ("%s -- `%s'", inst.error, str);
11410       return;
11411     }
11412
11413   to = frag_more (inst.size);
11414
11415   if (thumb_mode && (inst.size > THUMB_SIZE))
11416     {
11417       assert (inst.size == (2 * THUMB_SIZE));
11418       md_number_to_chars (to, inst.instruction >> 16, THUMB_SIZE);
11419       md_number_to_chars (to + THUMB_SIZE, inst.instruction, THUMB_SIZE);
11420     }
11421   else if (inst.size > INSN_SIZE)
11422     {
11423       assert (inst.size == (2 * INSN_SIZE));
11424       md_number_to_chars (to, inst.instruction, INSN_SIZE);
11425       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
11426     }
11427   else
11428     md_number_to_chars (to, inst.instruction, inst.size);
11429
11430   if (inst.reloc.type != BFD_RELOC_NONE)
11431     fix_new_arm (frag_now, to - frag_now->fr_literal,
11432                  inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
11433                  inst.reloc.type);
11434
11435 #ifdef OBJ_ELF
11436   dwarf2_emit_insn (inst.size);
11437 #endif
11438 }
11439
11440 void
11441 md_assemble (str)
11442      char * str;
11443 {
11444   char  c;
11445   char *p;
11446   char *start;
11447
11448   /* Align the instruction.
11449      This may not be the right thing to do but ...  */
11450 #if 0
11451   arm_align (2, 0);
11452 #endif
11453
11454   /* Align the previous label if needed.  */
11455   if (last_label_seen != NULL)
11456     {
11457       symbol_set_frag (last_label_seen, frag_now);
11458       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
11459       S_SET_SEGMENT (last_label_seen, now_seg);
11460     }
11461
11462   memset (&inst, '\0', sizeof (inst));
11463   inst.reloc.type = BFD_RELOC_NONE;
11464
11465   skip_whitespace (str);
11466
11467   /* Scan up to the end of the op-code, which must end in white space or
11468      end of string.  */
11469   for (start = p = str; *p != '\0'; p++)
11470     if (*p == ' ')
11471       break;
11472
11473   if (p == str)
11474     {
11475       as_bad (_("no operator -- statement `%s'\n"), str);
11476       return;
11477     }
11478
11479   if (thumb_mode)
11480     {
11481       const struct thumb_opcode * opcode;
11482
11483       c = *p;
11484       *p = '\0';
11485       opcode = (const struct thumb_opcode *) hash_find (arm_tops_hsh, str);
11486       *p = c;
11487
11488       if (opcode)
11489         {
11490           /* Check that this instruction is supported for this CPU.  */
11491           if (thumb_mode == 1 && (opcode->variant & cpu_variant) == 0)
11492             {
11493               as_bad (_("selected processor does not support `%s'"), str);
11494               return;
11495             }
11496
11497           inst.instruction = opcode->value;
11498           inst.size = opcode->size;
11499           (*opcode->parms) (p);
11500           output_inst (str);
11501           return;
11502         }
11503     }
11504   else
11505     {
11506       const struct asm_opcode * opcode;
11507
11508       c = *p;
11509       *p = '\0';
11510       opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, str);
11511       *p = c;
11512
11513       if (opcode)
11514         {
11515           /* Check that this instruction is supported for this CPU.  */
11516           if ((opcode->variant & cpu_variant) == 0)
11517             {
11518               as_bad (_("selected processor does not support `%s'"), str);
11519               return;
11520             }
11521
11522           inst.instruction = opcode->value;
11523           inst.size = INSN_SIZE;
11524           (*opcode->parms) (p);
11525           output_inst (str);
11526           return;
11527         }
11528     }
11529
11530   /* It wasn't an instruction, but it might be a register alias of the form
11531      alias .req reg.  */
11532   if (create_register_alias (str, p))
11533     return;
11534
11535   as_bad (_("bad instruction `%s'"), start);
11536 }
11537
11538 /* md_parse_option
11539       Invocation line includes a switch not recognized by the base assembler.
11540       See if it's a processor-specific option.
11541
11542       This routine is somewhat complicated by the need for backwards
11543       compatibility (since older releases of gcc can't be changed).
11544       The new options try to make the interface as compatible as
11545       possible with GCC.
11546
11547       New options (supported) are:
11548
11549               -mcpu=<cpu name>           Assemble for selected processor
11550               -march=<architecture name> Assemble for selected architecture
11551               -mfpu=<fpu architecture>   Assemble for selected FPU.
11552               -EB/-mbig-endian           Big-endian
11553               -EL/-mlittle-endian        Little-endian
11554               -k                         Generate PIC code
11555               -mthumb                    Start in Thumb mode
11556               -mthumb-interwork          Code supports ARM/Thumb interworking
11557
11558       For now we will also provide support for:
11559
11560               -mapcs-32                  32-bit Program counter
11561               -mapcs-26                  26-bit Program counter
11562               -macps-float               Floats passed in FP registers
11563               -mapcs-reentrant           Reentrant code
11564               -matpcs
11565       (sometime these will probably be replaced with -mapcs=<list of options>
11566       and -matpcs=<list of options>)
11567
11568       The remaining options are only supported for back-wards compatibility.
11569       Cpu variants, the arm part is optional:
11570               -m[arm]1                Currently not supported.
11571               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
11572               -m[arm]3                Arm 3 processor
11573               -m[arm]6[xx],           Arm 6 processors
11574               -m[arm]7[xx][t][[d]m]   Arm 7 processors
11575               -m[arm]8[10]            Arm 8 processors
11576               -m[arm]9[20][tdmi]      Arm 9 processors
11577               -mstrongarm[110[0]]     StrongARM processors
11578               -mxscale                XScale processors
11579               -m[arm]v[2345[t[e]]]    Arm architectures
11580               -mall                   All (except the ARM1)
11581       FP variants:
11582               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
11583               -mfpe-old               (No float load/store multiples)
11584               -mvfpxd                 VFP Single precision
11585               -mvfp                   All VFP
11586               -mno-fpu                Disable all floating point instructions
11587
11588       The following CPU names are recognized:
11589               arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
11590               arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
11591               arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
11592               arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
11593               arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
11594               arm10t arm10e, arm1020t, arm1020e, arm10200e,
11595               strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
11596
11597       */
11598
11599 const char * md_shortopts = "m:k";
11600
11601 #ifdef ARM_BI_ENDIAN
11602 #define OPTION_EB (OPTION_MD_BASE + 0)
11603 #define OPTION_EL (OPTION_MD_BASE + 1)
11604 #else
11605 #if TARGET_BYTES_BIG_ENDIAN
11606 #define OPTION_EB (OPTION_MD_BASE + 0)
11607 #else
11608 #define OPTION_EL (OPTION_MD_BASE + 1)
11609 #endif
11610 #endif
11611
11612 struct option md_longopts[] =
11613 {
11614 #ifdef OPTION_EB
11615   {"EB", no_argument, NULL, OPTION_EB},
11616 #endif
11617 #ifdef OPTION_EL
11618   {"EL", no_argument, NULL, OPTION_EL},
11619 #endif
11620   {NULL, no_argument, NULL, 0}
11621 };
11622
11623 size_t md_longopts_size = sizeof (md_longopts);
11624
11625 struct arm_option_table
11626 {
11627   char *option;         /* Option name to match.  */
11628   char *help;           /* Help information.  */
11629   int  *var;            /* Variable to change.  */
11630   int   value;          /* What to change it to.  */
11631   char *deprecated;     /* If non-null, print this message.  */
11632 };
11633
11634 struct arm_option_table arm_opts[] =
11635 {
11636   {"k",      N_("generate PIC code"),      &pic_code,    1, NULL},
11637   {"mthumb", N_("assemble Thumb code"),    &thumb_mode,  1, NULL},
11638   {"mthumb-interwork", N_("support ARM/Thumb interworking"),
11639    &support_interwork, 1, NULL},
11640   {"moabi",  N_("use old ABI (ELF only)"), &target_oabi, 1, NULL},
11641   {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26, 0, NULL},
11642   {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26, 1, NULL},
11643   {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float,
11644    1, NULL},
11645   {"mapcs-reentrant", N_("re-entrant code"), &pic_code, 1, NULL},
11646   {"matpcs", N_("code is ATPCS conformant"), &atpcs, 1, NULL},
11647   {"mbig-endian", N_("assemble for big-endian"), &target_big_endian, 1, NULL},
11648   {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian, 1,
11649    NULL},
11650
11651   /* These are recognized by the assembler, but have no affect on code.  */
11652   {"mapcs-frame", N_("use frame pointer"), NULL, 0, NULL},
11653   {"mapcs-stack-check", N_("use stack size checking"), NULL, 0, NULL},
11654
11655   /* DON'T add any new processors to this list -- we want the whole list
11656      to go away...  Add them to the processors table instead.  */
11657   {"marm1",      NULL, &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
11658   {"m1",         NULL, &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
11659   {"marm2",      NULL, &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
11660   {"m2",         NULL, &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
11661   {"marm250",    NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
11662   {"m250",       NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
11663   {"marm3",      NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
11664   {"m3",         NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
11665   {"marm6",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
11666   {"m6",         NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
11667   {"marm600",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
11668   {"m600",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
11669   {"marm610",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
11670   {"m610",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
11671   {"marm620",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
11672   {"m620",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
11673   {"marm7",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
11674   {"m7",         NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
11675   {"marm70",     NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
11676   {"m70",        NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
11677   {"marm700",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
11678   {"m700",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
11679   {"marm700i",   NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
11680   {"m700i",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
11681   {"marm710",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
11682   {"m710",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
11683   {"marm710c",   NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
11684   {"m710c",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
11685   {"marm720",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
11686   {"m720",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
11687   {"marm7d",     NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
11688   {"m7d",        NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
11689   {"marm7di",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
11690   {"m7di",       NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
11691   {"marm7m",     NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
11692   {"m7m",        NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
11693   {"marm7dm",    NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
11694   {"m7dm",       NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
11695   {"marm7dmi",   NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
11696   {"m7dmi",      NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
11697   {"marm7100",   NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
11698   {"m7100",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
11699   {"marm7500",   NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
11700   {"m7500",      NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
11701   {"marm7500fe", NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
11702   {"m7500fe",    NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
11703   {"marm7t",     NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
11704   {"m7t",        NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
11705   {"marm7tdmi",  NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
11706   {"m7tdmi",     NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
11707   {"marm710t",   NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
11708   {"m710t",      NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
11709   {"marm720t",   NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
11710   {"m720t",      NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
11711   {"marm740t",   NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
11712   {"m740t",      NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
11713   {"marm8",      NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
11714   {"m8",         NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
11715   {"marm810",    NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
11716   {"m810",       NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
11717   {"marm9",      NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
11718   {"m9",         NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
11719   {"marm9tdmi",  NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
11720   {"m9tdmi",     NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
11721   {"marm920",    NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
11722   {"m920",       NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
11723   {"marm940",    NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
11724   {"m940",       NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
11725   {"mstrongarm", NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=strongarm")},
11726   {"mstrongarm110", NULL, &legacy_cpu, ARM_ARCH_V4,
11727    N_("use -mcpu=strongarm110")},
11728   {"mstrongarm1100", NULL, &legacy_cpu, ARM_ARCH_V4,
11729    N_("use -mcpu=strongarm1100")},
11730   {"mstrongarm1110", NULL, &legacy_cpu, ARM_ARCH_V4,
11731    N_("use -mcpu=strongarm1110")},
11732   {"mxscale",    NULL, &legacy_cpu, ARM_ARCH_XSCALE, N_("use -mcpu=xscale")},
11733   {"miwmmxt",    NULL, &legacy_cpu, ARM_ARCH_IWMMXT, N_("use -mcpu=iwmmxt")},
11734   {"mall",       NULL, &legacy_cpu, ARM_ANY,      N_("use -mcpu=all")},
11735
11736   /* Architecture variants -- don't add any more to this list either.  */
11737   {"mv2",        NULL, &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
11738   {"marmv2",     NULL, &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
11739   {"mv2a",       NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
11740   {"marmv2a",    NULL, &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
11741   {"mv3",        NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
11742   {"marmv3",     NULL, &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
11743   {"mv3m",       NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
11744   {"marmv3m",    NULL, &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
11745   {"mv4",        NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
11746   {"marmv4",     NULL, &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
11747   {"mv4t",       NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
11748   {"marmv4t",    NULL, &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
11749   {"mv5",        NULL, &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
11750   {"marmv5",     NULL, &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
11751   {"mv5t",       NULL, &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
11752   {"marmv5t",    NULL, &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
11753   {"mv5e",       NULL, &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
11754   {"marmv5e",    NULL, &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
11755
11756   /* Floating point variants -- don't add any more to this list either.  */
11757   {"mfpe-old", NULL, &legacy_fpu, FPU_ARCH_FPE, N_("use -mfpu=fpe")},
11758   {"mfpa10",   NULL, &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa10")},
11759   {"mfpa11",   NULL, &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa11")},
11760   {"mno-fpu",  NULL, &legacy_fpu, 0,
11761    N_("use either -mfpu=softfpa or -mfpu=softvfp")},
11762
11763   {NULL, NULL, NULL, 0, NULL}
11764 };
11765
11766 struct arm_cpu_option_table
11767 {
11768   char *name;
11769   int   value;
11770   /* For some CPUs we assume an FPU unless the user explicitly sets
11771      -mfpu=...  */
11772   int   default_fpu;
11773 };
11774
11775 /* This list should, at a minimum, contain all the cpu names
11776    recognized by GCC.  */
11777 static struct arm_cpu_option_table arm_cpus[] =
11778 {
11779   {"all",               ARM_ANY,         FPU_ARCH_FPA},
11780   {"arm1",              ARM_ARCH_V1,     FPU_ARCH_FPA},
11781   {"arm2",              ARM_ARCH_V2,     FPU_ARCH_FPA},
11782   {"arm250",            ARM_ARCH_V2S,    FPU_ARCH_FPA},
11783   {"arm3",              ARM_ARCH_V2S,    FPU_ARCH_FPA},
11784   {"arm6",              ARM_ARCH_V3,     FPU_ARCH_FPA},
11785   {"arm60",             ARM_ARCH_V3,     FPU_ARCH_FPA},
11786   {"arm600",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11787   {"arm610",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11788   {"arm620",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11789   {"arm7",              ARM_ARCH_V3,     FPU_ARCH_FPA},
11790   {"arm7m",             ARM_ARCH_V3M,    FPU_ARCH_FPA},
11791   {"arm7d",             ARM_ARCH_V3,     FPU_ARCH_FPA},
11792   {"arm7dm",            ARM_ARCH_V3M,    FPU_ARCH_FPA},
11793   {"arm7di",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11794   {"arm7dmi",           ARM_ARCH_V3M,    FPU_ARCH_FPA},
11795   {"arm70",             ARM_ARCH_V3,     FPU_ARCH_FPA},
11796   {"arm700",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11797   {"arm700i",           ARM_ARCH_V3,     FPU_ARCH_FPA},
11798   {"arm710",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11799   {"arm710t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11800   {"arm720",            ARM_ARCH_V3,     FPU_ARCH_FPA},
11801   {"arm720t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11802   {"arm740t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11803   {"arm710c",           ARM_ARCH_V3,     FPU_ARCH_FPA},
11804   {"arm7100",           ARM_ARCH_V3,     FPU_ARCH_FPA},
11805   {"arm7500",           ARM_ARCH_V3,     FPU_ARCH_FPA},
11806   {"arm7500fe",         ARM_ARCH_V3,     FPU_ARCH_FPA},
11807   {"arm7t",             ARM_ARCH_V4T,    FPU_ARCH_FPA},
11808   {"arm7tdmi",          ARM_ARCH_V4T,    FPU_ARCH_FPA},
11809   {"arm8",              ARM_ARCH_V4,     FPU_ARCH_FPA},
11810   {"arm810",            ARM_ARCH_V4,     FPU_ARCH_FPA},
11811   {"strongarm",         ARM_ARCH_V4,     FPU_ARCH_FPA},
11812   {"strongarm1",        ARM_ARCH_V4,     FPU_ARCH_FPA},
11813   {"strongarm110",      ARM_ARCH_V4,     FPU_ARCH_FPA},
11814   {"strongarm1100",     ARM_ARCH_V4,     FPU_ARCH_FPA},
11815   {"strongarm1110",     ARM_ARCH_V4,     FPU_ARCH_FPA},
11816   {"arm9",              ARM_ARCH_V4T,    FPU_ARCH_FPA},
11817   {"arm920",            ARM_ARCH_V4T,    FPU_ARCH_FPA},
11818   {"arm920t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11819   {"arm922t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11820   {"arm940t",           ARM_ARCH_V4T,    FPU_ARCH_FPA},
11821   {"arm9tdmi",          ARM_ARCH_V4T,    FPU_ARCH_FPA},
11822   /* For V5 or later processors we default to using VFP; but the user
11823      should really set the FPU type explicitly.  */
11824   {"arm9e-r0",          ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2},
11825   {"arm9e",             ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11826   {"arm926ej",          ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2},
11827   {"arm946e-r0",        ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2},
11828   {"arm946e",           ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11829   {"arm966e-r0",        ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2},
11830   {"arm966e",           ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11831   {"arm10t",            ARM_ARCH_V5T,    FPU_ARCH_VFP_V1},
11832   {"arm10e",            ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11833   {"arm1020",           ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11834   {"arm1020t",          ARM_ARCH_V5T,    FPU_ARCH_VFP_V1},
11835   {"arm1020e",          ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2},
11836   /* ??? XSCALE is really an architecture.  */
11837   {"xscale",            ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2},
11838   /* ??? iwmmxt is not a processor.  */
11839   {"iwmmxt",            ARM_ARCH_IWMMXT, FPU_ARCH_VFP_V2},
11840   {"i80200",            ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2},
11841   /* Maverick */
11842   {"ep9312",            ARM_ARCH_V4T | ARM_CEXT_MAVERICK, FPU_NONE},
11843   {NULL, 0, 0}
11844 };
11845
11846 struct arm_arch_option_table
11847 {
11848   char *name;
11849   int   value;
11850   int   default_fpu;
11851 };
11852
11853 /* This list should, at a minimum, contain all the architecture names
11854    recognized by GCC.  */
11855 static struct arm_arch_option_table arm_archs[] =
11856 {
11857   {"all",               ARM_ANY,         FPU_ARCH_FPA},
11858   {"armv1",             ARM_ARCH_V1,     FPU_ARCH_FPA},
11859   {"armv2",             ARM_ARCH_V2,     FPU_ARCH_FPA},
11860   {"armv2a",            ARM_ARCH_V2S,    FPU_ARCH_FPA},
11861   {"armv2s",            ARM_ARCH_V2S,    FPU_ARCH_FPA},
11862   {"armv3",             ARM_ARCH_V3,     FPU_ARCH_FPA},
11863   {"armv3m",            ARM_ARCH_V3M,    FPU_ARCH_FPA},
11864   {"armv4",             ARM_ARCH_V4,     FPU_ARCH_FPA},
11865   {"armv4xm",           ARM_ARCH_V4xM,   FPU_ARCH_FPA},
11866   {"armv4t",            ARM_ARCH_V4T,    FPU_ARCH_FPA},
11867   {"armv4txm",          ARM_ARCH_V4TxM,  FPU_ARCH_FPA},
11868   {"armv5",             ARM_ARCH_V5,     FPU_ARCH_VFP},
11869   {"armv5t",            ARM_ARCH_V5T,    FPU_ARCH_VFP},
11870   {"armv5txm",          ARM_ARCH_V5TxM,  FPU_ARCH_VFP},
11871   {"armv5te",           ARM_ARCH_V5TE,   FPU_ARCH_VFP},
11872   {"armv5texp",         ARM_ARCH_V5TExP, FPU_ARCH_VFP},
11873   {"armv5tej",          ARM_ARCH_V5TEJ,  FPU_ARCH_VFP},
11874   {"xscale",            ARM_ARCH_XSCALE, FPU_ARCH_VFP},
11875   {NULL, 0, 0}
11876 };
11877
11878 /* ISA extensions in the co-processor space.  */
11879 struct arm_arch_extension_table
11880 {
11881   char *name;
11882   int value;
11883 };
11884
11885 static struct arm_arch_extension_table arm_extensions[] =
11886 {
11887   {"maverick",          ARM_CEXT_MAVERICK},
11888   {"xscale",            ARM_CEXT_XSCALE},
11889   {"iwmmxt",            ARM_CEXT_IWMMXT},
11890   {NULL,                0}
11891 };
11892
11893 struct arm_fpu_option_table
11894 {
11895   char *name;
11896   int   value;
11897 };
11898
11899 /* This list should, at a minimum, contain all the fpu names
11900    recognized by GCC.  */
11901 static struct arm_fpu_option_table arm_fpus[] =
11902 {
11903   {"softfpa",           FPU_NONE},
11904   {"fpe",               FPU_ARCH_FPE},
11905   {"fpe2",              FPU_ARCH_FPE},
11906   {"fpe3",              FPU_ARCH_FPA},  /* Third release supports LFM/SFM.  */
11907   {"fpa",               FPU_ARCH_FPA},
11908   {"fpa10",             FPU_ARCH_FPA},
11909   {"fpa11",             FPU_ARCH_FPA},
11910   {"arm7500fe",         FPU_ARCH_FPA},
11911   {"softvfp",           FPU_ARCH_VFP},
11912   {"softvfp+vfp",       FPU_ARCH_VFP_V2},
11913   {"vfp",               FPU_ARCH_VFP_V2},
11914   {"vfp9",              FPU_ARCH_VFP_V2},
11915   {"vfp10",             FPU_ARCH_VFP_V2},
11916   {"vfp10-r0",          FPU_ARCH_VFP_V1},
11917   {"vfpxd",             FPU_ARCH_VFP_V1xD},
11918   {"arm1020t",          FPU_ARCH_VFP_V1},
11919   {"arm1020e",          FPU_ARCH_VFP_V2},
11920   {NULL, 0}
11921 };
11922
11923 struct arm_long_option_table
11924 {
11925   char *option;         /* Substring to match.  */
11926   char *help;           /* Help information.  */
11927   int (*func) PARAMS ((char *subopt));  /* Function to decode sub-option.  */
11928   char *deprecated;     /* If non-null, print this message.  */
11929 };
11930
11931 static int
11932 arm_parse_extension (str, opt_p)
11933      char *str;
11934      int *opt_p;
11935 {
11936   while (str != NULL && *str != 0)
11937     {
11938       struct arm_arch_extension_table *opt;
11939       char *ext;
11940       int optlen;
11941
11942       if (*str != '+')
11943         {
11944           as_bad (_("invalid architectural extension"));
11945           return 0;
11946         }
11947
11948       str++;
11949       ext = strchr (str, '+');
11950
11951       if (ext != NULL)
11952         optlen = ext - str;
11953       else
11954         optlen = strlen (str);
11955
11956       if (optlen == 0)
11957         {
11958           as_bad (_("missing architectural extension"));
11959           return 0;
11960         }
11961
11962       for (opt = arm_extensions; opt->name != NULL; opt++)
11963         if (strncmp (opt->name, str, optlen) == 0)
11964           {
11965             *opt_p |= opt->value;
11966             break;
11967           }
11968
11969       if (opt->name == NULL)
11970         {
11971           as_bad (_("unknown architectural extnsion `%s'"), str);
11972           return 0;
11973         }
11974
11975       str = ext;
11976     };
11977
11978   return 1;
11979 }
11980
11981 static int
11982 arm_parse_cpu (str)
11983      char *str;
11984 {
11985   struct arm_cpu_option_table *opt;
11986   char *ext = strchr (str, '+');
11987   int optlen;
11988
11989   if (ext != NULL)
11990     optlen = ext - str;
11991   else
11992     optlen = strlen (str);
11993
11994   if (optlen == 0)
11995     {
11996       as_bad (_("missing cpu name `%s'"), str);
11997       return 0;
11998     }
11999
12000   for (opt = arm_cpus; opt->name != NULL; opt++)
12001     if (strncmp (opt->name, str, optlen) == 0)
12002       {
12003         mcpu_cpu_opt = opt->value;
12004         mcpu_fpu_opt = opt->default_fpu;
12005
12006         if (ext != NULL)
12007           return arm_parse_extension (ext, &mcpu_cpu_opt);
12008
12009         return 1;
12010       }
12011
12012   as_bad (_("unknown cpu `%s'"), str);
12013   return 0;
12014 }
12015
12016 static int
12017 arm_parse_arch (str)
12018      char *str;
12019 {
12020   struct arm_arch_option_table *opt;
12021   char *ext = strchr (str, '+');
12022   int optlen;
12023
12024   if (ext != NULL)
12025     optlen = ext - str;
12026   else
12027     optlen = strlen (str);
12028
12029   if (optlen == 0)
12030     {
12031       as_bad (_("missing architecture name `%s'"), str);
12032       return 0;
12033     }
12034
12035
12036   for (opt = arm_archs; opt->name != NULL; opt++)
12037     if (strcmp (opt->name, str) == 0)
12038       {
12039         march_cpu_opt = opt->value;
12040         march_fpu_opt = opt->default_fpu;
12041
12042         if (ext != NULL)
12043           return arm_parse_extension (ext, &march_cpu_opt);
12044
12045         return 1;
12046       }
12047
12048   as_bad (_("unknown architecture `%s'\n"), str);
12049   return 0;
12050 }
12051
12052 static int
12053 arm_parse_fpu (str)
12054      char *str;
12055 {
12056   struct arm_fpu_option_table *opt;
12057
12058   for (opt = arm_fpus; opt->name != NULL; opt++)
12059     if (strcmp (opt->name, str) == 0)
12060       {
12061         mfpu_opt = opt->value;
12062         return 1;
12063       }
12064
12065   as_bad (_("unknown floating point format `%s'\n"), str);
12066   return 0;
12067 }
12068
12069 struct arm_long_option_table arm_long_opts[] =
12070 {
12071   {"mcpu=", N_("<cpu name>\t  assemble for CPU <cpu name>"),
12072    arm_parse_cpu, NULL},
12073   {"march=", N_("<arch name>\t  assemble for architecture <arch name>"),
12074    arm_parse_arch, NULL},
12075   {"mfpu=", N_("<fpu name>\t  assemble for FPU architecture <fpu name>"),
12076    arm_parse_fpu, NULL},
12077   {NULL, NULL, 0, NULL}
12078 };
12079
12080 int
12081 md_parse_option (c, arg)
12082      int    c;
12083      char * arg;
12084 {
12085   struct arm_option_table *opt;
12086   struct arm_long_option_table *lopt;
12087
12088   switch (c)
12089     {
12090 #ifdef OPTION_EB
12091     case OPTION_EB:
12092       target_big_endian = 1;
12093       break;
12094 #endif
12095
12096 #ifdef OPTION_EL
12097     case OPTION_EL:
12098       target_big_endian = 0;
12099       break;
12100 #endif
12101
12102     case 'a':
12103       /* Listing option.  Just ignore these, we don't support additional
12104          ones.  */
12105       return 0;
12106
12107     default:
12108       for (opt = arm_opts; opt->option != NULL; opt++)
12109         {
12110           if (c == opt->option[0]
12111               && ((arg == NULL && opt->option[1] == 0)
12112                   || strcmp (arg, opt->option + 1) == 0))
12113             {
12114 #if WARN_DEPRECATED
12115               /* If the option is deprecated, tell the user.  */
12116               if (opt->deprecated != NULL)
12117                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
12118                            arg ? arg : "", _(opt->deprecated));
12119 #endif
12120
12121               if (opt->var != NULL)
12122                 *opt->var = opt->value;
12123
12124               return 1;
12125             }
12126         }
12127
12128       for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
12129         {
12130           /* These options are expected to have an argument.  */
12131           if (c == lopt->option[0]
12132               && arg != NULL
12133               && strncmp (arg, lopt->option + 1,
12134                           strlen (lopt->option + 1)) == 0)
12135             {
12136 #if WARN_DEPRECATED
12137               /* If the option is deprecated, tell the user.  */
12138               if (lopt->deprecated != NULL)
12139                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c, arg,
12140                            _(lopt->deprecated));
12141 #endif
12142
12143               /* Call the sup-option parser.  */
12144               return (*lopt->func)(arg + strlen (lopt->option) - 1);
12145             }
12146         }
12147
12148       as_bad (_("unrecognized option `-%c%s'"), c, arg ? arg : "");
12149       return 0;
12150     }
12151
12152   return 1;
12153 }
12154
12155 void
12156 md_show_usage (fp)
12157      FILE * fp;
12158 {
12159   struct arm_option_table *opt;
12160   struct arm_long_option_table *lopt;
12161
12162   fprintf (fp, _(" ARM-specific assembler options:\n"));
12163
12164   for (opt = arm_opts; opt->option != NULL; opt++)
12165     if (opt->help != NULL)
12166       fprintf (fp, "  -%-23s%s\n", opt->option, _(opt->help));
12167
12168   for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
12169     if (lopt->help != NULL)
12170       fprintf (fp, "  -%s%s\n", lopt->option, _(lopt->help));
12171
12172 #ifdef OPTION_EB
12173   fprintf (fp, _("\
12174   -EB                     assemble code for a big-endian cpu\n"));
12175 #endif
12176
12177 #ifdef OPTION_EL
12178   fprintf (fp, _("\
12179   -EL                     assemble code for a little-endian cpu\n"));
12180 #endif
12181 }
12182
12183 /* We need to be able to fix up arbitrary expressions in some statements.
12184    This is so that we can handle symbols that are an arbitrary distance from
12185    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
12186    which returns part of an address in a form which will be valid for
12187    a data instruction.  We do this by pushing the expression into a symbol
12188    in the expr_section, and creating a fix for that.  */
12189
12190 static void
12191 fix_new_arm (frag, where, size, exp, pc_rel, reloc)
12192      fragS *       frag;
12193      int           where;
12194      short int     size;
12195      expressionS * exp;
12196      int           pc_rel;
12197      int           reloc;
12198 {
12199   fixS *           new_fix;
12200   arm_fix_data *   arm_data;
12201
12202   switch (exp->X_op)
12203     {
12204     case O_constant:
12205     case O_symbol:
12206     case O_add:
12207     case O_subtract:
12208       new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
12209       break;
12210
12211     default:
12212       new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0,
12213                          pc_rel, reloc);
12214       break;
12215     }
12216
12217   /* Mark whether the fix is to a THUMB instruction, or an ARM
12218      instruction.  */
12219   arm_data = (arm_fix_data *) obstack_alloc (& notes, sizeof (arm_fix_data));
12220   new_fix->tc_fix_data = (PTR) arm_data;
12221   arm_data->thumb_mode = thumb_mode;
12222
12223   return;
12224 }
12225
12226 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
12227
12228 void
12229 cons_fix_new_arm (frag, where, size, exp)
12230      fragS *       frag;
12231      int           where;
12232      int           size;
12233      expressionS * exp;
12234 {
12235   bfd_reloc_code_real_type type;
12236   int pcrel = 0;
12237
12238   /* Pick a reloc.
12239      FIXME: @@ Should look at CPU word size.  */
12240   switch (size)
12241     {
12242     case 1:
12243       type = BFD_RELOC_8;
12244       break;
12245     case 2:
12246       type = BFD_RELOC_16;
12247       break;
12248     case 4:
12249     default:
12250       type = BFD_RELOC_32;
12251       break;
12252     case 8:
12253       type = BFD_RELOC_64;
12254       break;
12255     }
12256
12257   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
12258 }
12259
12260 /* A good place to do this, although this was probably not intended
12261    for this kind of use.  We need to dump the literal pool before
12262    references are made to a null symbol pointer.  */
12263
12264 void
12265 arm_cleanup ()
12266 {
12267   literal_pool * pool;
12268
12269   for (pool = list_of_pools; pool; pool = pool->next)
12270     {
12271       /* Put it at the end of the relevent section.  */
12272       subseg_set (pool->section, pool->sub_section);
12273       s_ltorg (0);
12274     }
12275 }
12276
12277 void
12278 arm_start_line_hook ()
12279 {
12280   last_label_seen = NULL;
12281 }
12282
12283 void
12284 arm_frob_label (sym)
12285      symbolS * sym;
12286 {
12287   last_label_seen = sym;
12288
12289   ARM_SET_THUMB (sym, thumb_mode);
12290
12291 #if defined OBJ_COFF || defined OBJ_ELF
12292   ARM_SET_INTERWORK (sym, support_interwork);
12293 #endif
12294
12295   /* Note - do not allow local symbols (.Lxxx) to be labeled
12296      as Thumb functions.  This is because these labels, whilst
12297      they exist inside Thumb code, are not the entry points for
12298      possible ARM->Thumb calls.  Also, these labels can be used
12299      as part of a computed goto or switch statement.  eg gcc
12300      can generate code that looks like this:
12301
12302                 ldr  r2, [pc, .Laaa]
12303                 lsl  r3, r3, #2
12304                 ldr  r2, [r3, r2]
12305                 mov  pc, r2
12306
12307        .Lbbb:  .word .Lxxx
12308        .Lccc:  .word .Lyyy
12309        ..etc...
12310        .Laaa:   .word Lbbb
12311
12312      The first instruction loads the address of the jump table.
12313      The second instruction converts a table index into a byte offset.
12314      The third instruction gets the jump address out of the table.
12315      The fourth instruction performs the jump.
12316
12317      If the address stored at .Laaa is that of a symbol which has the
12318      Thumb_Func bit set, then the linker will arrange for this address
12319      to have the bottom bit set, which in turn would mean that the
12320      address computation performed by the third instruction would end
12321      up with the bottom bit set.  Since the ARM is capable of unaligned
12322      word loads, the instruction would then load the incorrect address
12323      out of the jump table, and chaos would ensue.  */
12324   if (label_is_thumb_function_name
12325       && (S_GET_NAME (sym)[0] != '.' || S_GET_NAME (sym)[1] != 'L')
12326       && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
12327     {
12328       /* When the address of a Thumb function is taken the bottom
12329          bit of that address should be set.  This will allow
12330          interworking between Arm and Thumb functions to work
12331          correctly.  */
12332
12333       THUMB_SET_FUNC (sym, 1);
12334
12335       label_is_thumb_function_name = FALSE;
12336     }
12337 }
12338
12339 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
12340    ARM ones.  */
12341
12342 void
12343 arm_adjust_symtab ()
12344 {
12345 #ifdef OBJ_COFF
12346   symbolS * sym;
12347
12348   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
12349     {
12350       if (ARM_IS_THUMB (sym))
12351         {
12352           if (THUMB_IS_FUNC (sym))
12353             {
12354               /* Mark the symbol as a Thumb function.  */
12355               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
12356                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
12357                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
12358
12359               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
12360                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
12361               else
12362                 as_bad (_("%s: unexpected function type: %d"),
12363                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
12364             }
12365           else switch (S_GET_STORAGE_CLASS (sym))
12366             {
12367             case C_EXT:
12368               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
12369               break;
12370             case C_STAT:
12371               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
12372               break;
12373             case C_LABEL:
12374               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
12375               break;
12376             default:
12377               /* Do nothing.  */
12378               break;
12379             }
12380         }
12381
12382       if (ARM_IS_INTERWORK (sym))
12383         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
12384     }
12385 #endif
12386 #ifdef OBJ_ELF
12387   symbolS * sym;
12388   char      bind;
12389
12390   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
12391     {
12392       if (ARM_IS_THUMB (sym))
12393         {
12394           elf_symbol_type * elf_sym;
12395
12396           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
12397           bind = ELF_ST_BIND (elf_sym);
12398
12399           /* If it's a .thumb_func, declare it as so,
12400              otherwise tag label as .code 16.  */
12401           if (THUMB_IS_FUNC (sym))
12402             elf_sym->internal_elf_sym.st_info =
12403               ELF_ST_INFO (bind, STT_ARM_TFUNC);
12404           else
12405             elf_sym->internal_elf_sym.st_info =
12406               ELF_ST_INFO (bind, STT_ARM_16BIT);
12407         }
12408     }
12409 #endif
12410 }
12411
12412 int
12413 arm_data_in_code ()
12414 {
12415   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
12416     {
12417       *input_line_pointer = '/';
12418       input_line_pointer += 5;
12419       *input_line_pointer = 0;
12420       return 1;
12421     }
12422
12423   return 0;
12424 }
12425
12426 char *
12427 arm_canonicalize_symbol_name (name)
12428      char * name;
12429 {
12430   int len;
12431
12432   if (thumb_mode && (len = strlen (name)) > 5
12433       && streq (name + len - 5, "/data"))
12434     *(name + len - 5) = 0;
12435
12436   return name;
12437 }
12438
12439 #if defined OBJ_COFF || defined OBJ_ELF
12440 void
12441 arm_validate_fix (fixP)
12442      fixS * fixP;
12443 {
12444   /* If the destination of the branch is a defined symbol which does not have
12445      the THUMB_FUNC attribute, then we must be calling a function which has
12446      the (interfacearm) attribute.  We look for the Thumb entry point to that
12447      function and change the branch to refer to that function instead.  */
12448   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
12449       && fixP->fx_addsy != NULL
12450       && S_IS_DEFINED (fixP->fx_addsy)
12451       && ! THUMB_IS_FUNC (fixP->fx_addsy))
12452     {
12453       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
12454     }
12455 }
12456 #endif
12457
12458 int
12459 arm_force_relocation (fixp)
12460      struct fix * fixp;
12461 {
12462 #if defined (OBJ_COFF) && defined (TE_PE)
12463   if (fixp->fx_r_type == BFD_RELOC_RVA)
12464     return 1;
12465 #endif
12466 #ifdef OBJ_ELF
12467   if (fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
12468       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
12469       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX
12470       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)
12471     return 1;
12472 #endif
12473
12474   /* Resolve these relocations even if the symbol is extern or weak.  */
12475   if (fixp->fx_r_type == BFD_RELOC_ARM_IMMEDIATE
12476       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM
12477       || fixp->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE)
12478     return 0;
12479
12480   return generic_force_reloc (fixp);
12481 }
12482
12483 #ifdef OBJ_COFF
12484 /* This is a little hack to help the gas/arm/adrl.s test.  It prevents
12485    local labels from being added to the output symbol table when they
12486    are used with the ADRL pseudo op.  The ADRL relocation should always
12487    be resolved before the binbary is emitted, so it is safe to say that
12488    it is adjustable.  */
12489
12490 bfd_boolean
12491 arm_fix_adjustable (fixP)
12492    fixS * fixP;
12493 {
12494   if (fixP->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE)
12495     return 1;
12496   return 0;
12497 }
12498 #endif
12499
12500 #ifdef OBJ_ELF
12501 /* Relocations against Thumb function names must be left unadjusted,
12502    so that the linker can use this information to correctly set the
12503    bottom bit of their addresses.  The MIPS version of this function
12504    also prevents relocations that are mips-16 specific, but I do not
12505    know why it does this.
12506
12507    FIXME:
12508    There is one other problem that ought to be addressed here, but
12509    which currently is not:  Taking the address of a label (rather
12510    than a function) and then later jumping to that address.  Such
12511    addresses also ought to have their bottom bit set (assuming that
12512    they reside in Thumb code), but at the moment they will not.  */
12513
12514 bfd_boolean
12515 arm_fix_adjustable (fixP)
12516    fixS * fixP;
12517 {
12518   if (fixP->fx_addsy == NULL)
12519     return 1;
12520
12521   if (THUMB_IS_FUNC (fixP->fx_addsy)
12522       && fixP->fx_subsy == NULL)
12523     return 0;
12524
12525   /* We need the symbol name for the VTABLE entries.  */
12526   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
12527       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
12528     return 0;
12529
12530   /* Don't allow symbols to be discarded on GOT related relocs.  */
12531   if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32
12532       || fixP->fx_r_type == BFD_RELOC_ARM_GOT32
12533       || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF)
12534     return 0;
12535
12536   return 1;
12537 }
12538
12539 const char *
12540 elf32_arm_target_format ()
12541 {
12542   if (target_big_endian)
12543     {
12544       if (target_oabi)
12545         return "elf32-bigarm-oabi";
12546       else
12547         return "elf32-bigarm";
12548     }
12549   else
12550     {
12551       if (target_oabi)
12552         return "elf32-littlearm-oabi";
12553       else
12554         return "elf32-littlearm";
12555     }
12556 }
12557
12558 void
12559 armelf_frob_symbol (symp, puntp)
12560      symbolS * symp;
12561      int *     puntp;
12562 {
12563   elf_frob_symbol (symp, puntp);
12564 }
12565
12566 static bfd_reloc_code_real_type
12567 arm_parse_reloc ()
12568 {
12569   char         id [16];
12570   char *       ip;
12571   unsigned int i;
12572   static struct
12573   {
12574     char * str;
12575     int    len;
12576     bfd_reloc_code_real_type reloc;
12577   }
12578   reloc_map[] =
12579   {
12580 #define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
12581     MAP ("(got)",    BFD_RELOC_ARM_GOT32),
12582     MAP ("(gotoff)", BFD_RELOC_ARM_GOTOFF),
12583     /* ScottB: Jan 30, 1998 - Added support for parsing "var(PLT)"
12584        branch instructions generated by GCC for PLT relocs.  */
12585     MAP ("(plt)",    BFD_RELOC_ARM_PLT32),
12586     { NULL, 0,         BFD_RELOC_UNUSED }
12587 #undef MAP
12588   };
12589
12590   for (i = 0, ip = input_line_pointer;
12591        i < sizeof (id) && (ISALNUM (*ip) || ISPUNCT (*ip));
12592        i++, ip++)
12593     id[i] = TOLOWER (*ip);
12594
12595   for (i = 0; reloc_map[i].str; i++)
12596     if (strncmp (id, reloc_map[i].str, reloc_map[i].len) == 0)
12597       break;
12598
12599   input_line_pointer += reloc_map[i].len;
12600
12601   return reloc_map[i].reloc;
12602 }
12603
12604 static void
12605 s_arm_elf_cons (nbytes)
12606      int nbytes;
12607 {
12608   expressionS exp;
12609
12610 #ifdef md_flush_pending_output
12611   md_flush_pending_output ();
12612 #endif
12613
12614   if (is_it_end_of_statement ())
12615     {
12616       demand_empty_rest_of_line ();
12617       return;
12618     }
12619
12620 #ifdef md_cons_align
12621   md_cons_align (nbytes);
12622 #endif
12623
12624   do
12625     {
12626       bfd_reloc_code_real_type reloc;
12627
12628       expression (& exp);
12629
12630       if (exp.X_op == O_symbol
12631           && * input_line_pointer == '('
12632           && (reloc = arm_parse_reloc ()) != BFD_RELOC_UNUSED)
12633         {
12634           reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, reloc);
12635           int size = bfd_get_reloc_size (howto);
12636
12637           if (size > nbytes)
12638             as_bad ("%s relocations do not fit in %d bytes",
12639                     howto->name, nbytes);
12640           else
12641             {
12642               register char *p = frag_more ((int) nbytes);
12643               int offset = nbytes - size;
12644
12645               fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
12646                            &exp, 0, reloc);
12647             }
12648         }
12649       else
12650         emit_expr (&exp, (unsigned int) nbytes);
12651     }
12652   while (*input_line_pointer++ == ',');
12653
12654   /* Put terminator back into stream.  */
12655   input_line_pointer --;
12656   demand_empty_rest_of_line ();
12657 }
12658
12659 #endif /* OBJ_ELF */
12660
12661 /* This is called from HANDLE_ALIGN in write.c.  Fill in the contents
12662    of an rs_align_code fragment.  */
12663
12664 void
12665 arm_handle_align (fragP)
12666      fragS *fragP;
12667 {
12668   static char const arm_noop[4] = { 0x00, 0x00, 0xa0, 0xe1 };
12669   static char const thumb_noop[2] = { 0xc0, 0x46 };
12670   static char const arm_bigend_noop[4] = { 0xe1, 0xa0, 0x00, 0x00 };
12671   static char const thumb_bigend_noop[2] = { 0x46, 0xc0 };
12672
12673   int bytes, fix, noop_size;
12674   char * p;
12675   const char * noop;
12676
12677   if (fragP->fr_type != rs_align_code)
12678     return;
12679
12680   bytes = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
12681   p = fragP->fr_literal + fragP->fr_fix;
12682   fix = 0;
12683
12684   if (bytes > MAX_MEM_FOR_RS_ALIGN_CODE)
12685     bytes &= MAX_MEM_FOR_RS_ALIGN_CODE;
12686
12687   if (fragP->tc_frag_data)
12688     {
12689       if (target_big_endian)
12690         noop = thumb_bigend_noop;
12691       else
12692         noop = thumb_noop;
12693       noop_size = sizeof (thumb_noop);
12694     }
12695   else
12696     {
12697       if (target_big_endian)
12698         noop = arm_bigend_noop;
12699       else
12700         noop = arm_noop;
12701       noop_size = sizeof (arm_noop);
12702     }
12703
12704   if (bytes & (noop_size - 1))
12705     {
12706       fix = bytes & (noop_size - 1);
12707       memset (p, 0, fix);
12708       p += fix;
12709       bytes -= fix;
12710     }
12711
12712   while (bytes >= noop_size)
12713     {
12714       memcpy (p, noop, noop_size);
12715       p += noop_size;
12716       bytes -= noop_size;
12717       fix += noop_size;
12718     }
12719
12720   fragP->fr_fix += fix;
12721   fragP->fr_var = noop_size;
12722 }
12723
12724 /* Called from md_do_align.  Used to create an alignment
12725    frag in a code section.  */
12726
12727 void
12728 arm_frag_align_code (n, max)
12729      int n;
12730      int max;
12731 {
12732   char * p;
12733
12734   /* We assume that there will never be a requirment
12735      to support alignments greater than 32 bytes.  */
12736   if (max > MAX_MEM_FOR_RS_ALIGN_CODE)
12737     as_fatal (_("alignments greater than 32 bytes not supported in .text sections."));
12738
12739   p = frag_var (rs_align_code,
12740                 MAX_MEM_FOR_RS_ALIGN_CODE,
12741                 1,
12742                 (relax_substateT) max,
12743                 (symbolS *) NULL,
12744                 (offsetT) n,
12745                 (char *) NULL);
12746   *p = 0;
12747
12748 }
12749
12750 /* Perform target specific initialisation of a frag.  */
12751
12752 void
12753 arm_init_frag (fragP)
12754      fragS *fragP;
12755 {
12756   /* Record whether this frag is in an ARM or a THUMB area.  */
12757   fragP->tc_frag_data = thumb_mode;
12758 }